@portabletext/editor 1.36.5 → 1.37.0

package/src/editor/editor-machine.ts

@@ -360,7 +360,10 @@ export const editorMachine = setup({
           withApplyingBehaviorActions(event.editor, () => {
             try {
               performAction({
-                context,
+                context: {
+                  keyGenerator: context.keyGenerator,
+                  schema: context.schema,
+                },
                 action: defaultAction,
               })
             } catch (error) {
@@ -379,6 +382,7 @@ export const editorMachine = setup({
           converters: [...context.converters],
           editor: event.editor,
           keyGenerator: context.keyGenerator,
+          readOnly: self.getSnapshot().matches({'edit mode': 'read only'}),
           schema: context.schema,
           hasTag: (tag) => self.getSnapshot().hasTag(tag),
         })
@@ -440,7 +444,13 @@ export const editorMachine = setup({
                 }
 
                 try {
-                  performAction({context, action: internalAction})
+                  performAction({
+                    context: {
+                      keyGenerator: context.keyGenerator,
+                      schema: context.schema,
+                    },
+                    action: internalAction,
+                  })
                 } catch (error) {
                   console.error(
                     new Error(
@@ -483,7 +493,10 @@ export const editorMachine = setup({
           withApplyingBehaviorActions(event.editor, () => {
             try {
               performAction({
-                context,
+                context: {
+                  keyGenerator: context.keyGenerator,
+                  schema: context.schema,
+                },
                 action: defaultAction,
               })
             } catch (error) {

package/src/editor/editor-selector.ts

@@ -73,6 +73,7 @@ export function getEditorSnapshot({
         slateEditorInstance,
       }),
       keyGenerator: editorActorSnapshot.context.keyGenerator,
+      readOnly: editorActorSnapshot.matches({'edit mode': 'read only'}),
       schema: editorActorSnapshot.context.schema,
       selection: editorActorSnapshot.context.selection,
       value: getValue({editorActorSnapshot, slateEditorInstance}),

package/src/editor/editor-snapshot.ts

@@ -15,6 +15,7 @@ export type EditorContext = {
   activeDecorators: Array<string>
   converters: Array<Converter>
   keyGenerator: () => string
+  readOnly: boolean
   schema: EditorSchema
   selection: EditorSelection
   value: Array<PortableTextBlock>
@@ -38,12 +39,14 @@ export function createEditorSnapshot({
   converters,
   editor,
   keyGenerator,
+  readOnly,
   schema,
   hasTag,
 }: {
   converters: Array<Converter>
   editor: PortableTextSlateEditor
   keyGenerator: () => string
+  readOnly: boolean
   schema: EditorSchema
   hasTag: HasTag
 }) {
@@ -61,6 +64,7 @@ export function createEditorSnapshot({
     }),
     converters,
     keyGenerator,
+    readOnly,
     schema,
     selection,
     value,

package/src/internal-utils/create-test-snapshot.ts

@@ -13,6 +13,7 @@ export function createTestSnapshot(snapshot: {
         snapshot.context?.schema ?? compileSchemaDefinition(defineSchema({})),
       keyGenerator: snapshot.context?.keyGenerator ?? createTestKeyGenerator(),
       activeDecorators: snapshot.context?.activeDecorators ?? [],
+      readOnly: snapshot.context?.readOnly ?? false,
       value: snapshot.context?.value ?? [],
       selection: snapshot.context?.selection ?? null,
     },

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

@@ -8,6 +8,28 @@ import type {EditorSchema} from '../editor/define-schema'
 import type {EditorContext} from '../editor/editor-snapshot'
 import {isTypedObject} from './asserters'
 
+export function parseBlocks({
+  context,
+  blocks,
+  options,
+}: {
+  context: Pick<EditorContext, 'keyGenerator' | 'schema'>
+  blocks: unknown
+  options: {
+    refreshKeys: boolean
+  }
+}): Array<PortableTextBlock> {
+  if (!Array.isArray(blocks)) {
+    return []
+  }
+
+  return blocks.flatMap((block) => {
+    const parsedBlock = parseBlock({context, block, options})
+
+    return parsedBlock ? [parsedBlock] : []
+  })
+}
+
 export function parseBlock({
   context,
   block,

package/src/selectors/index.ts

@@ -1,3 +1,4 @@
+export {isSelectingEntireBlocks} from './selector.is-selecting-entire-blocks'
 export {getActiveAnnotations} from './selector.get-active-annotations'
 export {getActiveListItem} from './selector.get-active-list-item'
 export {getActiveStyle} from './selector.get-active-style'
@@ -7,6 +8,7 @@ export {getAnchorSpan} from './selector.get-anchor-span'
 export {getAnchorTextBlock} from './selector.get-anchor-text-block'
 export {getBlockOffsets} from './selector.get-block-offsets'
 export {getCaretWordSelection} from './selector.get-caret-word-selection'
+export {getFocusInlineObject} from './selector.get-focus-inline-object'
 export {getNextInlineObject} from './selector.get-next-inline-object'
 export {getPreviousInlineObject} from './selector.get-previous-inline-object'
 export {getSelectedSlice} from './selector.get-selected-slice'

package/src/selectors/selector.get-focus-inline-object.ts

@@ -0,0 +1,21 @@
+import {
+  isPortableTextSpan,
+  type KeyedSegment,
+  type PortableTextObject,
+} from '@sanity/types'
+import type {EditorSelector} from '../editor/editor-selector'
+import {getFocusChild} from './selectors'
+
+/**
+ * @public
+ */
+export const getFocusInlineObject: EditorSelector<
+  | {node: PortableTextObject; path: [KeyedSegment, 'children', KeyedSegment]}
+  | undefined
+> = (snapshot) => {
+  const focusChild = getFocusChild(snapshot)
+
+  return focusChild && !isPortableTextSpan(focusChild.node)
+    ? {node: focusChild.node, path: focusChild.path}
+    : undefined
+}

package/src/selectors/selector.is-overlapping-selection.test.ts

@@ -0,0 +1,171 @@
+import {describe, expect, test} from 'vitest'
+import {createTestSnapshot} from '../internal-utils/create-test-snapshot'
+import type {EditorSelection} from '../types/editor'
+import {isOverlappingSelection} from './selector.is-overlapping-selection'
+
+function snapshot(selection: EditorSelection) {
+  return createTestSnapshot({
+    context: {
+      selection,
+      value: [
+        {_type: 'image', _key: 'k0'},
+        {
+          _type: 'block',
+          _key: 'k1',
+          children: [
+            {_type: 'span', _key: 'k3', text: 'foo'},
+            {_type: 'stock-ticker', _key: 'k4'},
+            {_type: 'span', _key: 'k5', text: 'bar'},
+          ],
+        },
+        {_type: 'image', _key: 'k2'},
+      ],
+    },
+  })
+}
+
+describe(isOverlappingSelection.name, () => {
+  test('null', () => {
+    expect(isOverlappingSelection(null)(snapshot(null))).toBe(false)
+  })
+
+  test('fully selected block object', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k0'}], offset: 0},
+        focus: {path: [{_key: 'k0'}], offset: 0},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k0'}], offset: 0},
+          focus: {path: [{_key: 'k0'}], offset: 0},
+        }),
+      ),
+    ).toBe(true)
+  })
+
+  test('block object inside selection', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k0'}], offset: 0},
+        focus: {path: [{_key: 'k0'}], offset: 0},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k0'}], offset: 0},
+          focus: {path: [{_key: 'k2'}], offset: 0},
+        }),
+      ),
+    ).toBe(true)
+  })
+
+  test('fully selected inline object', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
+        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
+          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
+        }),
+      ),
+    ).toBe(true)
+  })
+
+  test('inline object inside selection', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
+        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
+          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
+        }),
+      ),
+    ).toBe(true)
+  })
+
+  test('selection right before', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 0},
+        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
+          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
+        }),
+      ),
+    ).toBe(false)
+  })
+
+  test('selection overlapping from the start', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 0},
+        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
+          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
+        }),
+      ),
+    ).toBe(true)
+  })
+
+  test('selection right after', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
+        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 2},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
+          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
+        }),
+      ),
+    ).toBe(false)
+  })
+
+  test('selection overlapping from the end', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 0},
+        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 2},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
+          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
+        }),
+      ),
+    ).toBe(true)
+  })
+
+  test('before inline object', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
+        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
+          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
+        }),
+      ),
+    ).toBe(false)
+  })
+
+  test('after inline object', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 2},
+        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 2},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
+          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
+        }),
+      ),
+    ).toBe(false)
+  })
+})

package/src/selectors/selector.is-overlapping-selection.ts

@@ -1,4 +1,5 @@
 import type {EditorSelection} from '../types/editor'
+import {isEqualSelectionPoints} from '../utils'
 import type {EditorSelector} from './../editor/editor-selector'
 import {getSelectionEndPoint} from './selector.get-selection-end-point'
 import {getSelectionStartPoint} from './selector.get-selection-start-point'
@@ -31,18 +32,121 @@ export function isOverlappingSelection(
       },
     })
 
-    if (!selectionStartPoint || !selectionEndPoint) {
+    const originalSelectionStartPoint = getSelectionStartPoint(snapshot)
+    const originalSelectionEndPoint = getSelectionEndPoint(snapshot)
+
+    if (
+      !selectionStartPoint ||
+      !selectionEndPoint ||
+      !originalSelectionStartPoint ||
+      !originalSelectionEndPoint
+    ) {
       return false
     }
 
-    if (!isPointAfterSelection(selectionStartPoint)(snapshot)) {
+    const startPointBeforeSelection =
+      isPointBeforeSelection(selectionStartPoint)(snapshot)
+    const startPointAfterSelection =
+      isPointAfterSelection(selectionStartPoint)(snapshot)
+    const endPointBeforeSelection =
+      isPointBeforeSelection(selectionEndPoint)(snapshot)
+    const endPointAfterSelection =
+      isPointAfterSelection(selectionEndPoint)(snapshot)
+
+    const originalStartPointBeforeStartPoint = isPointBeforeSelection(
+      originalSelectionStartPoint,
+    )({
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: {
+          anchor: selectionStartPoint,
+          focus: selectionStartPoint,
+        },
+      },
+    })
+    const originalStartPointAfterStartPoint = isPointAfterSelection(
+      originalSelectionStartPoint,
+    )({
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: {
+          anchor: selectionStartPoint,
+          focus: selectionStartPoint,
+        },
+      },
+    })
+
+    const originalEndPointBeforeEndPoint = isPointBeforeSelection(
+      originalSelectionEndPoint,
+    )({
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: {
+          anchor: selectionEndPoint,
+          focus: selectionEndPoint,
+        },
+      },
+    })
+    const originalEndPointAfterEndPoint = isPointAfterSelection(
+      originalSelectionEndPoint,
+    )({
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: {
+          anchor: selectionEndPoint,
+          focus: selectionEndPoint,
+        },
+      },
+    })
+
+    const endPointEqualToOriginalStartPoint = isEqualSelectionPoints(
+      selectionEndPoint,
+      originalSelectionStartPoint,
+    )
+    const startPointEqualToOriginalEndPoint = isEqualSelectionPoints(
+      selectionStartPoint,
+      originalSelectionEndPoint,
+    )
+
+    if (endPointBeforeSelection && !endPointEqualToOriginalStartPoint) {
       return false
     }
 
-    if (!isPointBeforeSelection(selectionEndPoint)(snapshot)) {
+    if (startPointAfterSelection && !startPointEqualToOriginalEndPoint) {
       return false
     }
 
-    return true
+    if (
+      !originalStartPointBeforeStartPoint &&
+      originalStartPointAfterStartPoint &&
+      !originalEndPointBeforeEndPoint &&
+      originalEndPointAfterEndPoint
+    ) {
+      return !endPointEqualToOriginalStartPoint
+    }
+
+    if (
+      originalStartPointBeforeStartPoint &&
+      !originalStartPointAfterStartPoint &&
+      originalEndPointBeforeEndPoint &&
+      !originalEndPointAfterEndPoint
+    ) {
+      return !startPointEqualToOriginalEndPoint
+    }
+
+    if (
+      !startPointAfterSelection ||
+      !startPointBeforeSelection ||
+      !endPointAfterSelection ||
+      !endPointBeforeSelection
+    ) {
+      return true
+    }
+
+    return false
   }
 }

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

@@ -14,7 +14,9 @@ export function isPointAfterSelection(
       return false
     }
 
-    const selection = reverseSelection(snapshot.context.selection)
+    const selection = snapshot.context.selection.backward
+      ? reverseSelection(snapshot.context.selection)
+      : snapshot.context.selection
 
     const pointBlockKey = isKeySegment(point.path[0])
       ? point.path[0]._key

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

@@ -14,7 +14,9 @@ export function isPointBeforeSelection(
       return false
     }
 
-    const selection = reverseSelection(snapshot.context.selection)
+    const selection = snapshot.context.selection.backward
+      ? reverseSelection(snapshot.context.selection)
+      : snapshot.context.selection
 
     const pointBlockKey = isKeySegment(point.path[0])
       ? point.path[0]._key

package/src/selectors/selector.is-selecting-entire-blocks.ts

@@ -0,0 +1,34 @@
+import type {EditorSelector} from '../editor/editor-selector'
+import * as utils from '../utils'
+import {getSelectionEndBlock, getSelectionStartBlock} from './selectors'
+
+/**
+ * @public
+ */
+export const isSelectingEntireBlocks: EditorSelector<boolean> = (snapshot) => {
+  if (!snapshot.context.selection) {
+    return false
+  }
+
+  const startPoint = snapshot.context.selection.backward
+    ? snapshot.context.selection.focus
+    : snapshot.context.selection.anchor
+  const endPoint = snapshot.context.selection.backward
+    ? snapshot.context.selection.anchor
+    : snapshot.context.selection.focus
+
+  const startBlock = getSelectionStartBlock(snapshot)
+  const endBlock = getSelectionEndBlock(snapshot)
+
+  if (!startBlock || !endBlock) {
+    return false
+  }
+
+  const startBlockStartPoint = utils.getBlockStartPoint(startBlock)
+  const endBlockEndPoint = utils.getBlockEndPoint(endBlock)
+
+  return (
+    utils.isEqualSelectionPoints(startBlockStartPoint, startPoint) &&
+    utils.isEqualSelectionPoints(endBlockEndPoint, endPoint)
+  )
+}