@portabletext/editor 1.44.13 → 1.44.15

package/src/editor/plugins/createWithEditableAPI.ts

@@ -4,7 +4,6 @@ import {
   type PortableTextBlock,
   type PortableTextChild,
   type PortableTextObject,
-  type PortableTextSpan,
   type PortableTextTextBlock,
 } from '@sanity/types'
 import {
@@ -12,13 +11,12 @@ import {
   Node,
   Range,
   Element as SlateElement,
-  Path as SlatePath,
   Text,
   Transforms,
 } from 'slate'
 import type {DOMNode} from 'slate-dom'
 import {ReactEditor} from 'slate-react'
-import type {BehaviorActionImplementation} from '../../behavior-actions/behavior.actions'
+import {addAnnotationActionImplementation} from '../../behavior-actions/behavior.action.annotation.add'
 import {debugWithName} from '../../internal-utils/debug'
 import {toSlateRange} from '../../internal-utils/ranges'
 import {
@@ -608,282 +606,3 @@ function isAnnotationActive({
     return false
   }
 }
-
-/**
- * @public
- */
-export type AddedAnnotationPaths = {
-  /**
-   * @deprecated An annotation may be applied to multiple blocks, resulting
-   * in multiple `markDef`'s being created. Use `markDefPaths` instead.
-   */
-  markDefPath: Path
-  markDefPaths: Array<Path>
-  /**
-   * @deprecated Does not return anything meaningful since an annotation
-   * can span multiple blocks and spans. If references the span closest
-   * to the focus point of the selection.
-   */
-  spanPath: Path
-}
-
-export const addAnnotationActionImplementation: BehaviorActionImplementation<
-  'annotation.add',
-  AddedAnnotationPaths | undefined
-> = ({context, action}) => {
-  const editor = action.editor
-
-  if (!editor.selection || Range.isCollapsed(editor.selection)) {
-    return
-  }
-
-  let paths: AddedAnnotationPaths | undefined = undefined
-  let spanPath: Path | undefined
-  let markDefPath: Path | undefined
-  const markDefPaths: Path[] = []
-
-  const selectedBlocks = Editor.nodes(editor, {
-    at: editor.selection,
-    match: (node) => editor.isTextBlock(node),
-    reverse: Range.isBackward(editor.selection),
-  })
-
-  for (const [block, blockPath] of selectedBlocks) {
-    if (block.children.length === 0) {
-      continue
-    }
-
-    if (block.children.length === 1 && block.children[0].text === '') {
-      continue
-    }
-
-    const annotationKey = context.keyGenerator()
-    const markDefs = block.markDefs ?? []
-    const existingMarkDef = markDefs.find(
-      (markDef) =>
-        markDef._type === action.annotation.name &&
-        markDef._key === annotationKey,
-    )
-
-    if (existingMarkDef === undefined) {
-      Transforms.setNodes(
-        editor,
-        {
-          markDefs: [
-            ...markDefs,
-            {
-              _type: action.annotation.name,
-              _key: annotationKey,
-              ...action.annotation.value,
-            },
-          ],
-        },
-        {at: blockPath},
-      )
-
-      markDefPath = [{_key: block._key}, 'markDefs', {_key: annotationKey}]
-
-      if (Range.isBackward(editor.selection)) {
-        markDefPaths.unshift(markDefPath)
-      } else {
-        markDefPaths.push(markDefPath)
-      }
-    }
-
-    Transforms.setNodes(editor, {}, {match: Text.isText, split: true})
-
-    const children = Node.children(editor, blockPath)
-
-    for (const [span, path] of children) {
-      if (!editor.isTextSpan(span)) {
-        continue
-      }
-
-      if (!Range.includes(editor.selection, path)) {
-        continue
-      }
-
-      const marks = span.marks ?? []
-      const existingSameTypeAnnotations = marks.filter((mark) =>
-        markDefs.some(
-          (markDef) =>
-            markDef._key === mark && markDef._type === action.annotation.name,
-        ),
-      )
-
-      Transforms.setNodes(
-        editor,
-        {
-          marks: [
-            ...marks.filter(
-              (mark) => !existingSameTypeAnnotations.includes(mark),
-            ),
-            annotationKey,
-          ],
-        },
-        {at: path},
-      )
-
-      spanPath = [{_key: block._key}, 'children', {_key: span._key}]
-    }
-  }
-
-  if (markDefPath && spanPath) {
-    paths = {
-      markDefPath,
-      markDefPaths,
-      spanPath,
-    }
-  }
-
-  return paths
-}
-
-export const removeAnnotationActionImplementation: BehaviorActionImplementation<
-  'annotation.remove'
-> = ({action}) => {
-  const editor = action.editor
-
-  debug('Removing annotation', action.annotation.name)
-
-  if (!editor.selection) {
-    return
-  }
-
-  if (Range.isCollapsed(editor.selection)) {
-    const [block, blockPath] = Editor.node(editor, editor.selection, {
-      depth: 1,
-    })
-
-    if (!editor.isTextBlock(block)) {
-      return
-    }
-
-    const markDefs = block.markDefs ?? []
-    const potentialAnnotations = markDefs.filter(
-      (markDef) => markDef._type === action.annotation.name,
-    )
-
-    const [selectedChild, selectedChildPath] = Editor.node(
-      editor,
-      editor.selection,
-      {
-        depth: 2,
-      },
-    )
-
-    if (!editor.isTextSpan(selectedChild)) {
-      return
-    }
-
-    const annotationToRemove = selectedChild.marks?.find((mark) =>
-      potentialAnnotations.some((markDef) => markDef._key === mark),
-    )
-
-    if (!annotationToRemove) {
-      return
-    }
-
-    const previousSpansWithSameAnnotation: Array<
-      [span: PortableTextSpan, path: SlatePath]
-    > = []
-
-    for (const [child, childPath] of Node.children(editor, blockPath, {
-      reverse: true,
-    })) {
-      if (!editor.isTextSpan(child)) {
-        continue
-      }
-
-      if (!SlatePath.isBefore(childPath, selectedChildPath)) {
-        continue
-      }
-
-      if (child.marks?.includes(annotationToRemove)) {
-        previousSpansWithSameAnnotation.push([child, childPath])
-      } else {
-        break
-      }
-    }
-
-    const nextSpansWithSameAnnotation: Array<
-      [span: PortableTextSpan, path: SlatePath]
-    > = []
-
-    for (const [child, childPath] of Node.children(editor, blockPath)) {
-      if (!editor.isTextSpan(child)) {
-        continue
-      }
-
-      if (!SlatePath.isAfter(childPath, selectedChildPath)) {
-        continue
-      }
-
-      if (child.marks?.includes(annotationToRemove)) {
-        nextSpansWithSameAnnotation.push([child, childPath])
-      } else {
-        break
-      }
-    }
-
-    for (const [child, childPath] of [
-      ...previousSpansWithSameAnnotation,
-      [selectedChild, selectedChildPath] as const,
-      ...nextSpansWithSameAnnotation,
-    ]) {
-      Transforms.setNodes(
-        editor,
-        {
-          marks: child.marks?.filter((mark) => mark !== annotationToRemove),
-        },
-        {at: childPath},
-      )
-    }
-  } else {
-    Transforms.setNodes(
-      editor,
-      {},
-      {
-        match: (node) => editor.isTextSpan(node),
-        split: true,
-        hanging: true,
-      },
-    )
-
-    const blocks = Editor.nodes(editor, {
-      at: editor.selection,
-      match: (node) => editor.isTextBlock(node),
-    })
-
-    for (const [block, blockPath] of blocks) {
-      const children = Node.children(editor, blockPath)
-
-      for (const [child, childPath] of children) {
-        if (!editor.isTextSpan(child)) {
-          continue
-        }
-
-        if (!Range.includes(editor.selection, childPath)) {
-          continue
-        }
-
-        const markDefs = block.markDefs ?? []
-        const marks = child.marks ?? []
-        const marksWithoutAnnotation = marks.filter((mark) => {
-          const markDef = markDefs.find((markDef) => markDef._key === mark)
-          return markDef?._type !== action.annotation.name
-        })
-
-        if (marksWithoutAnnotation.length !== marks.length) {
-          Transforms.setNodes(
-            editor,
-            {
-              marks: marksWithoutAnnotation,
-            },
-            {at: childPath},
-          )
-        }
-      }
-    }
-  }
-}

package/src/index.ts

@@ -4,6 +4,8 @@ export type {
   PortableTextChild,
   PortableTextSpan,
 } from '@sanity/types'
+export type {AddedAnnotationPaths} from './behavior-actions/behavior.action.annotation.add'
+export {EditorEventListener} from './editor-event-listener'
 export type {Editor, EditorConfig, EditorEvent} from './editor/create-editor'
 export {
   defineSchema,
@@ -28,57 +30,55 @@ export type {EditorContext, EditorSnapshot} from './editor/editor-snapshot'
 export {usePortableTextEditor} from './editor/hooks/usePortableTextEditor'
 export {usePortableTextEditorSelection} from './editor/hooks/usePortableTextEditorSelection'
 export {defaultKeyGenerator as keyGenerator} from './editor/key-generator'
-export type {AddedAnnotationPaths} from './editor/plugins/createWithEditableAPI'
 export {PortableTextEditor} from './editor/PortableTextEditor'
 export type {PortableTextEditorProps} from './editor/PortableTextEditor'
-export {EditorEventListener} from './editor-event-listener'
 export type {BlockOffset} from './types/block-offset'
 export type {
-  EditableAPIDeleteOptions,
-  EditableAPI,
-  EditorSelectionPoint,
-  EditorSelection,
-  MutationChange,
-  PatchChange,
-  ValueChange,
-  SelectionChange,
-  FocusChange,
-  UnsetChange,
+  BlockAnnotationRenderProps,
+  BlockChildRenderProps,
+  BlockDecoratorRenderProps,
+  BlockListItemRenderProps,
+  BlockRenderProps,
+  BlockStyleRenderProps,
   BlurChange,
-  LoadingChange,
-  ReadyChange,
-  ErrorChange,
-  InvalidValueResolution,
-  InvalidValue,
-  UndoChange,
-  RedoChange,
   ConnectionChange,
+  EditableAPI,
+  EditableAPIDeleteOptions,
   EditorChange,
   EditorChanges,
+  EditorSelection,
+  EditorSelectionPoint,
+  ErrorChange,
+  FocusChange,
+  InvalidValue,
+  InvalidValueResolution,
+  LoadingChange,
+  MutationChange,
+  OnBeforeInputFn,
+  OnCopyFn,
+  OnPasteFn,
   OnPasteResult,
   OnPasteResultOrPromise,
   PasteData,
-  OnPasteFn,
-  OnBeforeInputFn,
-  OnCopyFn,
+  PatchChange,
   PatchObservable,
-  BlockRenderProps,
-  BlockChildRenderProps,
-  BlockAnnotationRenderProps,
-  BlockDecoratorRenderProps,
-  BlockListItemRenderProps,
+  PortableTextMemberSchemaTypes,
+  RangeDecoration,
+  RangeDecorationOnMovedDetails,
+  ReadyChange,
+  RedoChange,
+  RenderAnnotationFunction,
   RenderBlockFunction,
   RenderChildFunction,
+  RenderDecoratorFunction,
   RenderEditableFunction,
-  RenderAnnotationFunction,
+  RenderListItemFunction,
   RenderPlaceholderFunction,
   RenderStyleFunction,
-  BlockStyleRenderProps,
-  RenderListItemFunction,
-  RenderDecoratorFunction,
   ScrollSelectionIntoViewFunction,
-  RangeDecorationOnMovedDetails,
-  RangeDecoration,
-  PortableTextMemberSchemaTypes,
+  SelectionChange,
+  UndoChange,
+  UnsetChange,
+  ValueChange,
 } from './types/editor'
 export type {HotkeyOptions} from './types/options'