@portabletext/editor 1.20.0 → 1.21.1

package/src/index.ts

@@ -1,5 +1,9 @@
 export type {Patch} from '@portabletext/patches'
-export type {PortableTextBlock, PortableTextChild} from '@sanity/types'
+export type {
+  PortableTextBlock,
+  PortableTextChild,
+  PortableTextSpan,
+} from '@sanity/types'
 export type {
   Behavior,
   BehaviorActionIntend,

package/src/selectors/index.ts

@@ -16,6 +16,8 @@ export {isActiveAnnotation} from './selector.is-active-annotation'
 export {isActiveDecorator} from './selector.is-active-decorator'
 export {isActiveListItem} from './selector.is-active-list-item'
 export {isActiveStyle} from './selector.is-active-style'
+export {isPointAfterSelection} from './selector.is-point-after-selection'
+export {isPointBeforeSelection} from './selector.is-point-before-selection'
 export {isSelectionCollapsed} from './selector.is-selection-collapsed'
 export {isSelectionExpanded} from './selector.is-selection-expanded'
 export * from './selectors'

package/src/selectors/selector.get-selection-text.test.ts

@@ -0,0 +1,75 @@
+import {expect, test} from 'vitest'
+import type {EditorSchema, EditorSelection, EditorSnapshot} from '.'
+import {getSelectionText} from './selector.get-selection-text'
+
+test(getSelectionText.name, () => {
+  function snapshot(selection: EditorSelection): EditorSnapshot {
+    return {
+      context: {
+        schema: {} as EditorSchema,
+        keyGenerator: () => '',
+        activeDecorators: [],
+        value: [
+          {
+            _type: 'block',
+            _key: 'e0-k8',
+            style: 'normal',
+            markDefs: [],
+            children: [
+              {
+                _type: 'span',
+                _key: 'e0-k7',
+                text: ':b',
+                marks: [],
+              },
+              {
+                text: 'a',
+                _type: 'span',
+                _key: 'e0-k9',
+                marks: ['strong'],
+              },
+              {
+                text: 'r',
+                marks: [],
+                _type: 'span',
+                _key: 'e0-k10',
+              },
+            ],
+          },
+        ],
+        selection,
+      },
+    }
+  }
+
+  expect(
+    getSelectionText(
+      snapshot({
+        anchor: {
+          path: [
+            {
+              _key: 'e0-k8',
+            },
+            'children',
+            {
+              _key: 'e0-k7',
+            },
+          ],
+          offset: 0,
+        },
+        focus: {
+          path: [
+            {
+              _key: 'e0-k8',
+            },
+            'children',
+            {
+              _key: 'e0-k10',
+            },
+          ],
+          offset: 1,
+        },
+      }),
+    ),
+  ).toBe(':bar')
+})

package/src/selectors/selector.get-selection-text.ts

@@ -1,7 +1,7 @@
 import {isPortableTextSpan, isPortableTextTextBlock} from '@sanity/types'
 import type {EditorSelector} from '../editor/editor-selector'
-import {isKeyedSegment} from '../editor/utils/utils.is-keyed-segment'
-import {reverseSelection} from '../editor/utils/utils.reverse-selection'
+import {isKeyedSegment} from '../utils/util.is-keyed-segment'
+import {reverseSelection} from '../utils/util.reverse-selection'
 
 /**
  * @public
@@ -70,7 +70,7 @@ export const getSelectionText: EditorSelector<string> = ({context}) => {
         }
 
         if (text.length > 0) {
-          text + child.text
+          text = text + child.text
         }
       }
     }

package/src/selectors/selector.get-text-before.ts

@@ -1,7 +1,7 @@
 import type {EditorSelector} from '../editor/editor-selector'
-import {getStartPoint} from '../editor/utils/utils.get-start-point'
-import {isKeyedSegment} from '../editor/utils/utils.is-keyed-segment'
-import {reverseSelection} from '../editor/utils/utils.reverse-selection'
+import {getBlockStartPoint} from '../utils/util.get-block-start-point'
+import {isKeyedSegment} from '../utils/util.is-keyed-segment'
+import {reverseSelection} from '../utils/util.reverse-selection'
 import {getSelectionText} from './selector.get-selection-text'
 
 /**
@@ -26,7 +26,10 @@ export const getBlockTextBefore: EditorSelector<string> = ({context}) => {
     return ''
   }
 
-  const startOfBlock = getStartPoint({node: block, path: [{_key: block._key}]})
+  const startOfBlock = getBlockStartPoint({
+    node: block,
+    path: [{_key: block._key}],
+  })
 
   return getSelectionText({
     context: {

package/src/selectors/selector.is-point-after-selection.ts

@@ -0,0 +1,82 @@
+import {isKeySegment, isPortableTextTextBlock} from '@sanity/types'
+import type {EditorSelector} from '../editor/editor-selector'
+import type {EditorSelectionPoint} from '../types/editor'
+import {reverseSelection} from '../utils/util.reverse-selection'
+
+/**
+ * @public
+ */
+export function isPointAfterSelection(
+  point: EditorSelectionPoint,
+): EditorSelector<boolean> {
+  return (snapshot) => {
+    if (!snapshot.context.selection) {
+      return false
+    }
+
+    const selection = reverseSelection(snapshot.context.selection)
+
+    const pointBlockKey = isKeySegment(point.path[0])
+      ? point.path[0]._key
+      : undefined
+    const pointChildKey = isKeySegment(point.path[2])
+      ? point.path[2]._key
+      : undefined
+
+    const endBlockKey = isKeySegment(selection.focus.path[0])
+      ? selection.focus.path[0]._key
+      : undefined
+    const endChildKey = isKeySegment(selection.focus.path[2])
+      ? selection.focus.path[2]._key
+      : undefined
+
+    if (!pointBlockKey || !endBlockKey) {
+      return false
+    }
+
+    let after = false
+
+    for (const block of snapshot.context.value) {
+      if (block._key === endBlockKey) {
+        if (block._key !== pointBlockKey) {
+          after = true
+          break
+        }
+
+        // Both the point and the selection end in this block
+
+        if (!isPortableTextTextBlock(block)) {
+          break
+        }
+
+        if (!pointChildKey || !endChildKey) {
+          break
+        }
+
+        for (const child of block.children) {
+          if (child._key === endChildKey) {
+            if (child._key !== pointChildKey) {
+              after = true
+              break
+            }
+
+            // Both the point and the selection end in this child
+
+            after = point.offset > selection.focus.offset
+            break
+          }
+
+          if (child._key === pointChildKey) {
+            break
+          }
+        }
+      }
+
+      if (block._key === pointBlockKey) {
+        break
+      }
+    }
+
+    return after
+  }
+}

package/src/selectors/selector.is-point-before-selection.ts

@@ -0,0 +1,82 @@
+import {isKeySegment, isPortableTextTextBlock} from '@sanity/types'
+import type {EditorSelector} from '../editor/editor-selector'
+import type {EditorSelectionPoint} from '../types/editor'
+import {reverseSelection} from '../utils/util.reverse-selection'
+
+/**
+ * @public
+ */
+export function isPointBeforeSelection(
+  point: EditorSelectionPoint,
+): EditorSelector<boolean> {
+  return (snapshot) => {
+    if (!snapshot.context.selection) {
+      return false
+    }
+
+    const selection = reverseSelection(snapshot.context.selection)
+
+    const pointBlockKey = isKeySegment(point.path[0])
+      ? point.path[0]._key
+      : undefined
+    const pointChildKey = isKeySegment(point.path[2])
+      ? point.path[2]._key
+      : undefined
+
+    const startBlockKey = isKeySegment(selection.anchor.path[0])
+      ? selection.anchor.path[0]._key
+      : undefined
+    const startChildKey = isKeySegment(selection.anchor.path[2])
+      ? selection.anchor.path[2]._key
+      : undefined
+
+    if (!pointBlockKey || !startBlockKey) {
+      return false
+    }
+
+    let before = false
+
+    for (const block of snapshot.context.value) {
+      if (block._key === pointBlockKey) {
+        if (block._key !== startBlockKey) {
+          before = true
+          break
+        }
+
+        // Both the point and the selection start in this block
+
+        if (!isPortableTextTextBlock(block)) {
+          break
+        }
+
+        if (!pointChildKey || !startChildKey) {
+          break
+        }
+
+        for (const child of block.children) {
+          if (child._key === pointChildKey) {
+            if (child._key !== startChildKey) {
+              before = true
+              break
+            }
+
+            // Both the point and the selection start in this child
+
+            before = point.offset < selection.anchor.offset
+            break
+          }
+
+          if (child._key === startChildKey) {
+            break
+          }
+        }
+      }
+
+      if (block._key === startBlockKey) {
+        break
+      }
+    }
+
+    return before
+  }
+}

package/src/utils/_exports/index.ts

@@ -0,0 +1 @@
+export * from '../index'

package/src/utils/index.ts

@@ -0,0 +1,11 @@
+export type {BlockOffset} from '../behaviors/behavior.types'
+export type {EditorSelection, EditorSelectionPoint} from '../types/editor'
+export {
+  blockOffsetToSpanSelectionPoint,
+  spanSelectionPointToBlockOffset,
+} from './util.block-offset'
+export {getBlockStartPoint} from './util.get-block-start-point'
+export {getTextBlockText} from './util.get-text-block-text'
+export {isEmptyTextBlock} from './util.is-empty-text-block'
+export {isKeyedSegment} from './util.is-keyed-segment'
+export {reverseSelection} from './util.reverse-selection'

package/src/{editor/utils/utils.block-offset.test.ts → utils/util.block-offset.test.ts}

@@ -1,6 +1,6 @@
 import type {PortableTextBlock} from '@sanity/types'
 import {expect, test} from 'vitest'
-import {blockOffsetToSpanSelectionPoint} from './utils.block-offset'
+import {blockOffsetToSpanSelectionPoint} from './util.block-offset'
 
 test(blockOffsetToSpanSelectionPoint.name, () => {
   const value: Array<PortableTextBlock> = [

package/src/{editor/utils/utils.block-offset.ts → utils/util.block-offset.ts}

@@ -4,8 +4,13 @@ import {
   type KeyedSegment,
   type PortableTextBlock,
 } from '@sanity/types'
-import type {BlockOffset} from '../../behaviors/behavior.types'
+import type {BlockOffset} from '../behaviors/behavior.types'
+import type {EditorSelectionPoint} from '../types/editor'
+import {isKeyedSegment} from './util.is-keyed-segment'
 
+/**
+ * @public
+ */
 export function blockOffsetToSpanSelectionPoint({
   value,
   blockOffset,
@@ -55,20 +60,31 @@ export function blockOffsetToSpanSelectionPoint({
   return selectionPoint
 }
 
+/**
+ * @public
+ */
 export function spanSelectionPointToBlockOffset({
   value,
   selectionPoint,
 }: {
   value: Array<PortableTextBlock>
-  selectionPoint: {
-    path: [KeyedSegment, 'children', KeyedSegment]
-    offset: number
-  }
+  selectionPoint: EditorSelectionPoint
 }): BlockOffset | undefined {
   let offset = 0
 
+  const blockKey = isKeyedSegment(selectionPoint.path[0])
+    ? selectionPoint.path[0]._key
+    : undefined
+  const spanKey = isKeyedSegment(selectionPoint.path[2])
+    ? selectionPoint.path[2]._key
+    : undefined
+
+  if (!blockKey || !spanKey) {
+    return undefined
+  }
+
   for (const block of value) {
-    if (block._key !== selectionPoint.path[0]._key) {
+    if (block._key !== blockKey) {
       continue
     }
 
@@ -81,7 +97,7 @@ export function spanSelectionPointToBlockOffset({
         continue
       }
 
-      if (child._key === selectionPoint.path[2]._key) {
+      if (child._key === spanKey) {
         return {
           path: [{_key: block._key}],
           offset: offset + selectionPoint.offset,

package/src/{editor/utils/utils.get-start-point.ts → utils/util.get-block-start-point.ts}

@@ -3,9 +3,12 @@ import {
   type KeyedSegment,
   type PortableTextBlock,
 } from '@sanity/types'
-import type {EditorSelectionPoint} from '../../types/editor'
+import type {EditorSelectionPoint} from '../types/editor'
 
-export function getStartPoint({
+/**
+ * @public
+ */
+export function getBlockStartPoint({
   node,
   path,
 }: {

package/src/utils/util.get-text-block-text.ts

@@ -0,0 +1,8 @@
+import type {PortableTextTextBlock} from '@sanity/types'
+
+/**
+ * @public
+ */
+export function getTextBlockText(block: PortableTextTextBlock) {
+  return block.children.map((child) => child.text ?? '').join('')
+}

package/src/{editor/utils/utils.ts → utils/util.is-empty-text-block.ts}

@@ -2,9 +2,12 @@ import {
   isPortableTextSpan,
   isPortableTextTextBlock,
   type PortableTextBlock,
-  type PortableTextTextBlock,
 } from '@sanity/types'
+import {getTextBlockText} from './util.get-text-block-text'
 
+/**
+ * @public
+ */
 export function isEmptyTextBlock(block: PortableTextBlock) {
   if (!isPortableTextTextBlock(block)) {
     return false
@@ -15,7 +18,3 @@ export function isEmptyTextBlock(block: PortableTextBlock) {
 
   return onlyText && blockText === ''
 }
-
-export function getTextBlockText(block: PortableTextTextBlock) {
-  return block.children.map((child) => child.text ?? '').join('')
-}

package/src/{editor/utils/utils.is-keyed-segment.ts → utils/util.is-keyed-segment.ts}

@@ -1,5 +1,8 @@
 import type {KeyedSegment, PathSegment} from '@sanity/types'
 
+/**
+ * @public
+ */
 export function isKeyedSegment(segment: PathSegment): segment is KeyedSegment {
   return typeof segment === 'object' && segment !== null && '_key' in segment
 }

package/src/{editor/utils/utils.reverse-selection.ts → utils/util.reverse-selection.ts}

@@ -1,5 +1,8 @@
-import type {EditorSelection} from '../../types/editor'
+import type {EditorSelection} from '../types/editor'
 
+/**
+ * @public
+ */
 export function reverseSelection(
   selection: NonNullable<EditorSelection>,
 ): NonNullable<EditorSelection> {