@portabletext/editor 1.52.5 → 1.52.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "1.52.5",
+  "version": "1.52.7",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -89,16 +89,15 @@
     "@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",
     "@types/lodash": "^4.17.16",
     "@types/lodash.startcase": "^4.4.9",
-    "@types/react": "^19.1.4",
-    "@types/react-dom": "^19.1.5",
+    "@types/react": "^19.1.8",
+    "@types/react-dom": "^19.1.6",
     "@typescript-eslint/eslint-plugin": "^8.33.0",
     "@typescript-eslint/parser": "^8.33.0",
-    "@vitejs/plugin-react": "^4.4.1",
+    "@vitejs/plugin-react": "^4.5.2",
     "@vitest/browser": "^3.2.3",
     "@vitest/coverage-istanbul": "^3.2.3",
     "babel-plugin-react-compiler": "19.1.0-rc.1",
@@ -112,7 +111,7 @@
     "vite": "^6.2.5",
     "vitest": "^3.2.3",
     "vitest-browser-react": "^0.2.0",
-    "racejar": "1.2.5"
+    "racejar": "1.2.6"
   },
   "peerDependencies": {
     "@sanity/schema": "^3.92.0",

package/src/editor/Editable.tsx

@@ -15,7 +15,7 @@ import {
   type MutableRefObject,
   type TextareaHTMLAttributes,
 } from 'react'
-import {Transforms, type Text} from 'slate'
+import {Editor, Transforms, type Text} from 'slate'
 import {
   ReactEditor,
   Editable as SlateEditable,
@@ -29,7 +29,7 @@ import {parseBlocks} from '../internal-utils/parse-blocks'
 import {toSlateRange} from '../internal-utils/ranges'
 import {normalizeSelection} from '../internal-utils/selection'
 import {slateRangeToSelection} from '../internal-utils/slate-utils'
-import {fromSlateValue} from '../internal-utils/values'
+import {fromSlateValue, isEqualToEmptyEditor} from '../internal-utils/values'
 import {KEY_TO_VALUE_ELEMENT} from '../internal-utils/weakMaps'
 import type {
   EditorSelection,
@@ -534,9 +534,20 @@ export const PortableTextEditable = forwardRef<
 
       if (!event.isDefaultPrevented()) {
         relayActor.send({type: 'focused', event})
+
+        if (
+          !slateEditor.selection &&
+          isEqualToEmptyEditor(
+            slateEditor.children,
+            editorActor.getSnapshot().context.schema,
+          )
+        ) {
+          Transforms.select(slateEditor, Editor.start(slateEditor, []))
+          slateEditor.onChange()
+        }
       }
     },
-    [onFocus, relayActor],
+    [editorActor, onFocus, relayActor, slateEditor],
   )
 
   const handleClick = useCallback(

package/src/editor/plugins/createWithEditableAPI.ts

@@ -1,10 +1,9 @@
-import {
-  isPortableTextSpan,
-  type Path,
-  type PortableTextBlock,
-  type PortableTextChild,
-  type PortableTextObject,
-  type PortableTextTextBlock,
+import type {
+  Path,
+  PortableTextBlock,
+  PortableTextChild,
+  PortableTextObject,
+  PortableTextTextBlock,
 } from '@sanity/types'
 import {
   Editor,
@@ -29,6 +28,7 @@ import {
   SLATE_TO_PORTABLE_TEXT_RANGE,
 } from '../../internal-utils/weakMaps'
 import {addAnnotationOperationImplementation} from '../../operations/behavior.operation.annotation.add'
+import {isActiveAnnotation} from '../../selectors'
 import type {
   EditableAPI,
   EditableAPIDeleteOptions,
@@ -396,7 +396,12 @@ export function createEditableAPI(
     isAnnotationActive: (
       annotationType: PortableTextObject['_type'],
     ): boolean => {
-      return isAnnotationActive({editor, annotation: {name: annotationType}})
+      const snapshot = getEditorSnapshot({
+        editorActorSnapshot: editorActor.getSnapshot(),
+        slateEditorInstance: editor,
+      })
+
+      return isActiveAnnotation(annotationType)(snapshot)
     },
     addAnnotation: (type, value) => {
       let paths: ReturnType<EditableAPI['addAnnotation']> = undefined
@@ -546,59 +551,3 @@ export function createEditableAPI(
 
   return editableApi
 }
-
-function isAnnotationActive({
-  editor,
-  annotation,
-}: {
-  editor: PortableTextSlateEditor
-  annotation: {
-    name: string
-  }
-}) {
-  if (!editor.selection || editor.selection.focus.path.length < 2) {
-    return false
-  }
-
-  try {
-    const spans = [
-      ...Editor.nodes(editor, {
-        at: editor.selection,
-        match: (node) => Text.isText(node),
-      }),
-    ]
-
-    if (spans.length === 0) {
-      return false
-    }
-
-    if (
-      spans.some(
-        ([span]) =>
-          !isPortableTextSpan(span) || !span.marks || span.marks?.length === 0,
-      )
-    )
-      return false
-
-    const selectionMarkDefs = spans.reduce((accMarkDefs, [, path]) => {
-      const [block] = Editor.node(editor, path, {depth: 1})
-      if (editor.isTextBlock(block) && block.markDefs) {
-        return [...accMarkDefs, ...block.markDefs]
-      }
-      return accMarkDefs
-    }, [] as PortableTextObject[])
-
-    return spans.every(([span]) => {
-      if (!isPortableTextSpan(span)) return false
-
-      const spanMarkDefs = span.marks?.map(
-        (markKey) =>
-          selectionMarkDefs.find((def) => def?._key === markKey)?._type,
-      )
-
-      return spanMarkDefs?.includes(annotation.name)
-    })
-  } catch {
-    return false
-  }
-}

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

@@ -66,16 +66,16 @@ export const withPlugins = <T extends Editor>(
               withMaxBlocks(
                 withUndoRedo(
                   withPatches(
-                    pluginUpdateSelection({
-                      editorActor,
-                      editor: pluginUpdateValue(
+                    pluginUpdateValue(
+                      editorActor.getSnapshot().context,
+                      pluginUpdateMarkState(
                         editorActor.getSnapshot().context,
-                        pluginUpdateMarkState(
-                          editorActor.getSnapshot().context,
-                          e,
-                        ),
+                        pluginUpdateSelection({
+                          editorActor,
+                          editor: e,
+                        }),
                       ),
-                    }),
+                    ),
                   ),
                 ),
               ),

package/src/internal-utils/mark-state.ts

@@ -1,8 +1,9 @@
 import {Range} from 'slate'
 import type {EditorSchema} from '../editor/editor-schema'
+import {getSelectedSpans} from '../selectors'
 import type {PortableTextSlateEditor} from '../types/editor'
 import {getNextSpan, getPreviousSpan} from './sibling-utils'
-import {getFocusBlock, getFocusSpan, getSelectedSpans} from './slate-utils'
+import {getFocusBlock, getFocusSpan, slateRangeToSelection} from './slate-utils'
 
 export type MarkState = {
   state: 'changed' | 'unchanged'
@@ -36,18 +37,39 @@ export function getMarkState({
   }
 
   if (Range.isExpanded(editor.selection)) {
-    const selectedSpans = getSelectedSpans({editor})
+    const selection = editor.selection
+      ? slateRangeToSelection({
+          schema,
+          editor,
+          range: editor.selection,
+        })
+      : null
+
+    const selectedSpans = getSelectedSpans({
+      context: {
+        value: editor.value,
+        selection,
+        schema,
+        converters: [],
+        keyGenerator: () => '',
+        readOnly: false,
+      },
+      beta: {
+        activeAnnotations: [],
+        activeDecorators: [],
+      },
+    })
 
     let index = 0
     let marks: Array<string> = []
 
-    for (const [span] of selectedSpans) {
+    for (const span of selectedSpans) {
       if (index === 0) {
-        marks = span.marks ?? []
+        marks = span.node.marks ?? []
       } else {
         if (
-          span.marks?.length === 0 ||
-          (span.marks ?? [])?.some((mark) => !marks.includes(mark))
+          span.node.marks?.length === 0 ||
+          (span.node.marks ?? [])?.some((mark) => !marks.includes(mark))
         ) {
           marks = []
         }

package/src/internal-utils/slate-utils.ts

@@ -91,27 +91,6 @@ export function getFocusSpan({
   return [undefined, undefined]
 }
 
-export function getSelectedSpans({
-  editor,
-}: {
-  editor: PortableTextSlateEditor
-}): Array<[node: PortableTextSpan, path: Path]> {
-  if (!editor.selection) {
-    return []
-  }
-
-  try {
-    return Array.from(
-      Editor.nodes(editor, {
-        at: editor.selection,
-        match: (node) => editor.isTextSpan(node),
-      }),
-    )
-  } catch {
-    return []
-  }
-}
-
 export function getSelectionStartBlock({
   editor,
 }: {