@portabletext/editor 1.52.5 → 1.52.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "1.52.5",
+  "version": "1.52.6",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -80,8 +80,8 @@
     "slate-react": "0.114.2",
     "use-effect-event": "^1.0.2",
     "xstate": "^5.19.4",
-    "@portabletext/block-tools": "1.1.30",
-    "@portabletext/patches": "1.1.4"
+    "@portabletext/patches": "1.1.4",
+    "@portabletext/block-tools": "1.1.30"
   },
   "devDependencies": {
     "@portabletext/toolkit": "^2.0.17",

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,
 }: {