@portabletext/editor 1.52.0 → 1.52.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "1.52.0",
+  "version": "1.52.2",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -80,15 +80,15 @@
     "slate-react": "0.114.2",
     "use-effect-event": "^2.0.0",
     "xstate": "^5.19.4",
-    "@portabletext/block-tools": "1.1.29",
+    "@portabletext/block-tools": "1.1.30",
     "@portabletext/patches": "1.1.4"
   },
   "devDependencies": {
     "@portabletext/toolkit": "^2.0.17",
     "@sanity/diff-match-patch": "^3.2.0",
-    "@sanity/pkg-utils": "^7.2.3",
-    "@sanity/schema": "^3.91.0",
-    "@sanity/types": "^3.91.0",
+    "@sanity/pkg-utils": "^7.2.4",
+    "@sanity/schema": "^3.92.0",
+    "@sanity/types": "^3.92.0",
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.3.0",
     "@types/debug": "^4.1.12",
@@ -99,8 +99,8 @@
     "@typescript-eslint/eslint-plugin": "^8.33.0",
     "@typescript-eslint/parser": "^8.33.0",
     "@vitejs/plugin-react": "^4.4.1",
-    "@vitest/browser": "^3.2.1",
-    "@vitest/coverage-istanbul": "^3.2.1",
+    "@vitest/browser": "^3.2.3",
+    "@vitest/coverage-istanbul": "^3.2.3",
     "babel-plugin-react-compiler": "19.1.0-rc.1",
     "eslint": "8.57.1",
     "eslint-plugin-react-hooks": "0.0.0-experimental-f9ae0a4c-20250527",
@@ -110,13 +110,13 @@
     "rxjs": "^7.8.2",
     "typescript": "5.8.3",
     "vite": "^6.2.5",
-    "vitest": "^3.2.1",
+    "vitest": "^3.2.3",
     "vitest-browser-react": "^0.2.0",
     "racejar": "1.2.5"
   },
   "peerDependencies": {
-    "@sanity/schema": "^3.91.0",
-    "@sanity/types": "^3.91.0",
+    "@sanity/schema": "^3.92.0",
+    "@sanity/types": "^3.92.0",
     "react": "^16.9 || ^17 || ^18 || ^19",
     "rxjs": "^7.8.2"
   },

package/src/editor/components/render-element.tsx

@@ -2,11 +2,7 @@ import {useSelector} from '@xstate/react'
 import {useContext, type ReactElement} from 'react'
 import type {Element as SlateElement} from 'slate'
 import type {RenderElementProps} from 'slate-react'
-import {
-  parseBlockObject,
-  parseInlineObject,
-  parseTextBlock,
-} from '../../internal-utils/parse-blocks'
+import {isTextBlock} from '../../internal-utils/parse-blocks'
 import type {
   RenderBlockFunction,
   RenderChildFunction,
@@ -35,22 +31,19 @@ export function RenderElement(props: {
     '__inline' in props.element && props.element.__inline === true
 
   if (isInline) {
-    const inlineObject = parseInlineObject({
-      context: {
-        keyGenerator: () => '',
-        schema,
-      },
-      options: {refreshKeys: false, validateFields: false},
-      inlineObject: {
-        _key: props.element._key,
-        _type: props.element._type,
-        ...('value' in props.element && typeof props.element.value === 'object'
-          ? props.element.value
-          : {}),
-      },
-    })
+    const inlineObject = {
+      _key: props.element._key,
+      _type: props.element._type,
+      ...('value' in props.element && typeof props.element.value === 'object'
+        ? props.element.value
+        : {}),
+    }
 
-    if (!inlineObject) {
+    if (
+      !schema.inlineObjects.find(
+        (inlineObject) => inlineObject.name === props.element._type,
+      )
+    ) {
       console.error(
         `Unable to find Inline Object "${props.element._type}" in Schema`,
       )
@@ -74,16 +67,7 @@ export function RenderElement(props: {
     )
   }
 
-  const textBlock = parseTextBlock({
-    context: {
-      keyGenerator: () => '',
-      schema,
-    },
-    options: {refreshKeys: false, validateFields: false},
-    block: props.element,
-  })
-
-  if (textBlock) {
+  if (isTextBlock({schema}, props.element)) {
     return (
       <RenderTextBlock
         attributes={props.attributes}
@@ -93,29 +77,26 @@ export function RenderElement(props: {
         renderListItem={props.renderListItem}
         renderStyle={props.renderStyle}
         spellCheck={props.spellCheck}
-        textBlock={textBlock}
+        textBlock={props.element}
       >
         {props.children}
       </RenderTextBlock>
     )
   }
 
-  const blockObject = parseBlockObject({
-    context: {
-      keyGenerator: () => '',
-      schema,
-    },
-    options: {refreshKeys: false, validateFields: false},
-    blockObject: {
-      _key: props.element._key,
-      _type: props.element._type,
-      ...('value' in props.element && typeof props.element.value === 'object'
-        ? props.element.value
-        : {}),
-    },
-  })
+  const blockObject = {
+    _key: props.element._key,
+    _type: props.element._type,
+    ...('value' in props.element && typeof props.element.value === 'object'
+      ? props.element.value
+      : {}),
+  }
 
-  if (!blockObject) {
+  if (
+    !schema.blockObjects.find(
+      (blockObject) => blockObject.name === props.element._type,
+    )
+  ) {
     console.error(
       `Unable to find Block Object "${props.element._type}" in Schema`,
     )

package/src/editor/plugins/createWithSchemaTypes.ts

@@ -3,7 +3,7 @@ import type {
   PortableTextSpan,
   PortableTextTextBlock,
 } from '@sanity/types'
-import {Transforms, type Element} from 'slate'
+import {Editor, Transforms, type Element} from 'slate'
 import {debugWithName} from '../../internal-utils/debug'
 import {
   isListBlock,
@@ -27,15 +27,31 @@ export function createWithSchemaTypes({
     editor: PortableTextSlateEditor,
   ): PortableTextSlateEditor {
     editor.isTextBlock = (value: unknown): value is PortableTextTextBlock => {
+      if (Editor.isEditor(value)) {
+        return false
+      }
+
       return isTextBlock(editorActor.getSnapshot().context, value)
     }
     editor.isTextSpan = (value: unknown): value is PortableTextSpan => {
+      if (Editor.isEditor(value)) {
+        return false
+      }
+
       return isSpan(editorActor.getSnapshot().context, value)
     }
     editor.isListBlock = (value: unknown): value is PortableTextListBlock => {
+      if (Editor.isEditor(value)) {
+        return false
+      }
+
       return isListBlock(editorActor.getSnapshot().context, value)
     }
     editor.isVoid = (element: Element): boolean => {
+      if (Editor.isEditor(element)) {
+        return false
+      }
+
       return (
         editorActor.getSnapshot().context.schema.block.name !== element._type &&
         (editorActor
@@ -49,6 +65,10 @@ export function createWithSchemaTypes({
       )
     }
     editor.isInline = (element: Element): boolean => {
+      if (Editor.isEditor(element)) {
+        return false
+      }
+
       const inlineSchemaTypes = editorActor
         .getSnapshot()
         .context.schema.inlineObjects.map((obj) => obj.name)

package/src/editor/plugins/with-plugins.ts

@@ -7,7 +7,6 @@ import {createWithMaxBlocks} from './createWithMaxBlocks'
 import {createWithObjectKeys} from './createWithObjectKeys'
 import {createWithPatches} from './createWithPatches'
 import {createWithPlaceholderBlock} from './createWithPlaceholderBlock'
-import {createWithPortableTextBlockStyle} from './createWithPortableTextBlockStyle'
 import {createWithPortableTextMarkModel} from './createWithPortableTextMarkModel'
 import {createWithPortableTextSelections} from './createWithPortableTextSelections'
 import {createWithSchemaTypes} from './createWithSchemaTypes'
@@ -49,8 +48,6 @@ export const withPlugins = <T extends Editor>(
     subscriptions: options.subscriptions,
   })
   const withPortableTextMarkModel = createWithPortableTextMarkModel(editorActor)
-  const withPortableTextBlockStyle =
-    createWithPortableTextBlockStyle(editorActor)
 
   const withPlaceholderBlock = createWithPlaceholderBlock(editorActor)
 
@@ -66,19 +63,17 @@ export const withPlugins = <T extends Editor>(
     withSchemaTypes(
       withObjectKeys(
         withPortableTextMarkModel(
-          withPortableTextBlockStyle(
-            withPlaceholderBlock(
-              withUtils(
-                withMaxBlocks(
-                  withUndoRedo(
-                    withPatches(
-                      withPortableTextSelections(
-                        pluginUpdateValue(
+          withPlaceholderBlock(
+            withUtils(
+              withMaxBlocks(
+                withUndoRedo(
+                  withPatches(
+                    withPortableTextSelections(
+                      pluginUpdateValue(
+                        editorActor.getSnapshot().context,
+                        pluginUpdateMarkState(
                           editorActor.getSnapshot().context,
-                          pluginUpdateMarkState(
-                            editorActor.getSnapshot().context,
-                            e,
-                          ),
+                          e,
                         ),
                       ),
                     ),

package/src/internal-utils/create-placeholder-block.ts

@@ -1,3 +1,4 @@
+import type {PortableTextSpan} from '@sanity/types'
 import type {EditorContext} from '../editor/editor-snapshot'
 
 export function createPlaceholderBlock(
@@ -14,7 +15,7 @@ export function createPlaceholderBlock(
         _key: context.keyGenerator(),
         text: '',
         marks: [],
-      },
+      } as PortableTextSpan,
     ],
   }
 }

package/src/internal-utils/parse-blocks.ts

@@ -97,13 +97,19 @@ export function isTextBlock(
   context: Pick<EditorContext, 'schema'>,
   block: unknown,
 ): block is PortableTextTextBlock {
-  return (
-    parseTextBlock({
-      block,
-      context: {schema: context.schema, keyGenerator: () => ''},
-      options: {refreshKeys: false, validateFields: false},
-    }) !== undefined
-  )
+  if (!isTypedObject(block)) {
+    return false
+  }
+
+  if (block._type !== context.schema.block.name) {
+    return false
+  }
+
+  if (!Array.isArray(block.children)) {
+    return false
+  }
+
+  return true
 }
 
 export function parseTextBlock({
@@ -249,14 +255,19 @@ export function isSpan(
   context: Pick<EditorContext, 'schema'>,
   child: unknown,
 ): child is PortableTextSpan {
-  return (
-    parseSpan({
-      span: child,
-      markDefKeyMap: new Map(),
-      context: {schema: context.schema, keyGenerator: () => ''},
-      options: {refreshKeys: false, validateFields: false},
-    }) !== undefined
-  )
+  if (!isTypedObject(child)) {
+    return false
+  }
+
+  if (child._type !== context.schema.span.name) {
+    return false
+  }
+
+  if (typeof child.text !== 'string') {
+    return false
+  }
+
+  return true
 }
 
 export function parseSpan({

package/src/operations/behavior.operation.delete.ts

@@ -1,4 +1,5 @@
 import {Transforms} from 'slate'
+import {createPlaceholderBlock} from '../internal-utils/create-placeholder-block'
 import {toSlateRange} from '../internal-utils/ranges'
 import {getBlockPath} from '../internal-utils/slate-utils'
 import {getBlockKeyFromSelectionPoint} from '../selection/selection-point'
@@ -6,7 +7,7 @@ import type {BehaviorOperationImplementation} from './behavior.operations'
 
 export const deleteOperationImplementation: BehaviorOperationImplementation<
   'delete'
-> = ({operation}) => {
+> = ({context, operation}) => {
   const anchorBlockKey = getBlockKeyFromSelectionPoint(operation.at.anchor)
   const focusBlockKey = getBlockKeyFromSelectionPoint(operation.at.focus)
 
@@ -36,6 +37,10 @@ export const deleteOperationImplementation: BehaviorOperationImplementation<
       at: [anchorBlockPath[0]],
     })
 
+    if (operation.editor.children.length === 0) {
+      Transforms.insertNodes(operation.editor, createPlaceholderBlock(context))
+    }
+
     return
   }
 

package/src/editor/plugins/createWithPortableTextBlockStyle.ts

@@ -1,51 +0,0 @@
-import {Editor, Path, Text as SlateText, Transforms} from 'slate'
-import {debugWithName} from '../../internal-utils/debug'
-import type {PortableTextSlateEditor} from '../../types/editor'
-import type {EditorActor} from '../editor-machine'
-
-const debug = debugWithName('plugin:withPortableTextBlockStyle')
-
-export function createWithPortableTextBlockStyle(
-  editorActor: EditorActor,
-): (editor: PortableTextSlateEditor) => PortableTextSlateEditor {
-  const defaultStyle = editorActor.getSnapshot().context.schema.styles[0].name
-  return function withPortableTextBlockStyle(
-    editor: PortableTextSlateEditor,
-  ): PortableTextSlateEditor {
-    // Extend Slate's default normalization to reset split node to normal style
-    // if there is no text at the right end of the split.
-    const {normalizeNode} = editor
-
-    editor.normalizeNode = (nodeEntry) => {
-      const [, path] = nodeEntry
-
-      for (const op of editor.operations) {
-        if (
-          op.type === 'split_node' &&
-          op.path.length === 1 &&
-          editor.isTextBlock(op.properties) &&
-          op.properties.style !== defaultStyle &&
-          op.path[0] === path[0] &&
-          !Path.equals(path, op.path)
-        ) {
-          const [child] = Editor.node(editor, [op.path[0] + 1, 0])
-          if (SlateText.isText(child) && child.text === '') {
-            debug(`Normalizing split node to ${defaultStyle} style`, op)
-            editorActor.send({type: 'normalizing'})
-            Transforms.setNodes(
-              editor,
-              {style: defaultStyle},
-              {at: [op.path[0] + 1], voids: false},
-            )
-            editorActor.send({type: 'done normalizing'})
-            return
-          }
-        }
-      }
-
-      normalizeNode(nodeEntry)
-    }
-
-    return editor
-  }
-}