@portabletext/editor 1.54.5 → 1.55.0

package/src/internal-utils/build-index-maps.ts

@@ -0,0 +1,97 @@
+import type {PortableTextBlock} from '@sanity/types'
+import type {EditorContext} from '../editor/editor-snapshot'
+import {isTextBlock} from './parse-blocks'
+
+export function buildIndexMaps(
+  context: Pick<EditorContext, 'schema'>,
+  value: Array<PortableTextBlock>,
+): {
+  blockIndexMap: Map<string, number>
+  listIndexMap: Map<string, number>
+} {
+  const blockIndexMap = new Map<string, number>()
+  const listIndexMap = new Map<string, number>()
+  const levelIndexMap = new Map<number, number>()
+  let previousListItem:
+    | {
+        listItem: string
+        level: number
+      }
+    | undefined
+
+  for (let blockIndex = 0; blockIndex < value.length; blockIndex++) {
+    const block = value.at(blockIndex)
+
+    if (block === undefined) {
+      continue
+    }
+
+    blockIndexMap.set(block._key, blockIndex)
+
+    if (!isTextBlock(context, block)) {
+      levelIndexMap.clear()
+      previousListItem = undefined
+      continue
+    }
+
+    if (block.listItem === undefined || block.level === undefined) {
+      levelIndexMap.clear()
+      previousListItem = undefined
+      continue
+    }
+
+    if (!previousListItem) {
+      previousListItem = {
+        listItem: block.listItem,
+        level: block.level,
+      }
+      levelIndexMap.set(block.level, 1)
+      listIndexMap.set(block._key, 1)
+      continue
+    }
+
+    if (previousListItem.listItem !== block.listItem) {
+      levelIndexMap.clear()
+      previousListItem = {
+        listItem: block.listItem,
+        level: block.level,
+      }
+      levelIndexMap.set(block.level, 1)
+      listIndexMap.set(block._key, 1)
+      continue
+    }
+
+    if (previousListItem.level === block.level) {
+      const levelCounter = levelIndexMap.get(block.level) ?? 0
+      levelIndexMap.set(block.level, levelCounter + 1)
+      previousListItem = {
+        listItem: block.listItem,
+        level: block.level,
+      }
+      listIndexMap.set(block._key, levelCounter + 1)
+      continue
+    }
+
+    if (previousListItem.level < block.level) {
+      levelIndexMap.set(block.level, 1)
+      previousListItem = {
+        listItem: block.listItem,
+        level: block.level,
+      }
+      listIndexMap.set(block._key, 1)
+      continue
+    }
+
+    if (previousListItem.level > block.level) {
+      const levelCounter = levelIndexMap.get(block.level) ?? 0
+      levelIndexMap.set(block.level, levelCounter + 1)
+      previousListItem = {
+        listItem: block.listItem,
+        level: block.level,
+      }
+      listIndexMap.set(block._key, levelCounter + 1)
+    }
+  }
+
+  return {blockIndexMap, listIndexMap}
+}

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

@@ -6,16 +6,24 @@ export function createTestSnapshot(snapshot: {
   context?: Partial<EditorSnapshot['context']>
   beta?: Partial<EditorSnapshot['beta']>
 }): EditorSnapshot {
+  const context = {
+    converters: snapshot.context?.converters ?? [],
+    schema:
+      snapshot.context?.schema ?? compileSchemaDefinition(defineSchema({})),
+    keyGenerator: snapshot.context?.keyGenerator ?? createTestKeyGenerator(),
+    readOnly: snapshot.context?.readOnly ?? false,
+    value: snapshot.context?.value ?? [],
+    selection: snapshot.context?.selection ?? null,
+  }
+  const blockIndexMap = new Map<string, number>()
+
+  snapshot.context?.value?.forEach((block, index) => {
+    blockIndexMap.set(block._key, index)
+  })
+
   return {
-    context: {
-      converters: snapshot.context?.converters ?? [],
-      schema:
-        snapshot.context?.schema ?? compileSchemaDefinition(defineSchema({})),
-      keyGenerator: snapshot.context?.keyGenerator ?? createTestKeyGenerator(),
-      readOnly: snapshot.context?.readOnly ?? false,
-      value: snapshot.context?.value ?? [],
-      selection: snapshot.context?.selection ?? null,
-    },
+    blockIndexMap,
+    context,
     beta: {
       activeAnnotations: snapshot.beta?.activeAnnotations ?? [],
       activeDecorators: snapshot.beta?.activeDecorators ?? [],

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

@@ -46,6 +46,7 @@ export function getMarkState({
       : null
 
     const selectedSpans = getSelectedSpans({
+      blockIndexMap: editor.blockIndexMap,
       context: {
         value: editor.value,
         selection,

package/src/operations/behavior.operation.decorator.add.ts

@@ -108,6 +108,7 @@ export const decoratorAddOperationImplementation: BehaviorOperationImplementatio
     })
 
     const trimmedSelection = selectors.getTrimmedSelection({
+      blockIndexMap: editor.blockIndexMap,
       beta: {
         activeAnnotations: [],
         activeDecorators: [],

package/src/selectors/index.ts

@@ -31,6 +31,7 @@ export {getSelectionEndPoint} from './selector.get-selection-end-point'
 export {getSelectionStartBlock} from './selector.get-selection-start-block'
 export {getSelectionStartPoint} from './selector.get-selection-start-point'
 export {getSelectionText} from './selector.get-selection-text'
+export {getSelectedValue} from './selector.get-selected-value'
 export {getBlockTextBefore} from './selector.get-text-before'
 export {getTrimmedSelection} from './selector.get-trimmed-selection'
 export {getValue} from './selector.get-value'

package/src/selectors/selector.get-anchor-block.ts

@@ -14,10 +14,9 @@ export const getAnchorBlock: EditorSelector<
   }
 
   const key = getBlockKeyFromSelectionPoint(snapshot.context.selection.anchor)
-
-  const node = key
-    ? snapshot.context.value.find((block) => block._key === key)
-    : undefined
+  const index = key ? snapshot.blockIndexMap.get(key) : undefined
+  const node =
+    index !== undefined ? snapshot.context.value.at(index) : undefined
 
   return node && key ? {node, path: [{_key: key}]} : undefined
 }

package/src/selectors/selector.get-focus-block.ts

@@ -14,10 +14,10 @@ export const getFocusBlock: EditorSelector<
   }
 
   const key = getBlockKeyFromSelectionPoint(snapshot.context.selection.focus)
+  const index = key ? snapshot.blockIndexMap.get(key) : undefined
 
-  const node = key
-    ? snapshot.context.value.find((block) => block._key === key)
-    : undefined
+  const node =
+    index !== undefined ? snapshot.context.value.at(index) : undefined
 
   return node && key ? {node, path: [{_key: key}]} : undefined
 }

package/src/selectors/selector.get-list-state.ts

@@ -1,12 +1,11 @@
-import type {PortableTextTextBlock} from '@sanity/types'
 import type {EditorSelector} from '../editor/editor-selector'
 import {isTextBlock} from '../internal-utils/parse-blocks'
 import type {BlockPath} from '../types/paths'
 import {getFocusTextBlock} from './selector.get-focus-text-block'
-import {getPreviousBlock} from './selector.get-previous-block'
 
 /**
  * @beta
+ * @deprecated Use the precomputed `data-list-index` on text blocks instead.
  * Given the `path` of a block, this selector will return the "list index" of
  * the block.
  */
@@ -46,113 +45,52 @@ export function getListIndex({
       return undefined
     }
 
-    const previousListItem = getPreviousListItem({
-      listItem: focusTextBlock.node.listItem,
-      level: focusTextBlock.node.level,
-    })({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection,
-      },
-    })
+    const targetListItem = focusTextBlock.node.listItem
+    const targetLevel = focusTextBlock.node.level
+    const targetKey = focusTextBlock.node._key
 
-    if (!previousListItem) {
-      return 1
-    }
-
-    if (previousListItem.node.listItem !== focusTextBlock.node.listItem) {
-      return 1
-    }
+    // Find the target block's index
+    const targetIndex = snapshot.blockIndexMap.get(targetKey)
 
-    if (
-      previousListItem.node.level !== undefined &&
-      previousListItem.node.level < focusTextBlock.node.level
-    ) {
-      return 1
-    }
-
-    const previousListItemListState = getListIndex({
-      path: previousListItem.path,
-    })(snapshot)
-
-    if (previousListItemListState === undefined) {
-      return 1
+    if (targetIndex === undefined) {
+      return undefined
     }
 
-    return previousListItemListState + 1
-  }
-}
+    // Walk backwards from the target block and count consecutive list items
+    // of the same type and level
+    let listIndex = 1 // Start at 1 for the target block itself
 
-function getPreviousListItem({
-  listItem,
-  level,
-}: {
-  listItem: string
-  level: number
-}): EditorSelector<
-  | {
-      node: PortableTextTextBlock
-      path: [{_key: string}]
-    }
-  | undefined
-> {
-  return (snapshot) => {
-    const previousBlock = getPreviousBlock({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-      },
-    })
+    for (let i = targetIndex - 1; i >= 0; i--) {
+      const block = snapshot.context.value[i]
 
-    if (!previousBlock) {
-      return undefined
-    }
+      if (!isTextBlock(snapshot.context, block)) {
+        // Non-text block breaks the sequence
+        break
+      }
 
-    if (!isTextBlock(snapshot.context, previousBlock.node)) {
-      return undefined
-    }
+      if (block.listItem === undefined || block.level === undefined) {
+        // Non-list item breaks the sequence
+        break
+      }
 
-    if (
-      previousBlock.node.listItem === undefined ||
-      previousBlock.node.level === undefined
-    ) {
-      return undefined
-    }
+      if (block.listItem !== targetListItem) {
+        // Different list type breaks the sequence
+        break
+      }
 
-    if (previousBlock.node.listItem !== listItem) {
-      return undefined
-    }
+      if (block.level < targetLevel) {
+        // Lower level breaks the sequence
+        break
+      }
 
-    if (previousBlock.node.level === level) {
-      return {
-        node: previousBlock.node,
-        path: previousBlock.path,
+      if (block.level === targetLevel) {
+        // Same level - continue counting
+        listIndex++
       }
-    }
 
-    if (previousBlock.node.level < level) {
-      return undefined
+      // Higher level items don't affect the count for the target level
     }
 
-    return getPreviousListItem({
-      listItem,
-      level,
-    })({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection: {
-          anchor: {
-            path: previousBlock.path,
-            offset: 0,
-          },
-          focus: {
-            path: previousBlock.path,
-            offset: 0,
-          },
-        },
-      },
-    })
+    return listIndex
   }
 }

package/src/selectors/selector.get-next-block.ts

@@ -9,30 +9,21 @@ import {getSelectionEndBlock} from './selector.get-selection-end-block'
 export const getNextBlock: EditorSelector<
   {node: PortableTextBlock; path: BlockPath} | undefined
 > = (snapshot) => {
-  let nextBlock: {node: PortableTextBlock; path: BlockPath} | undefined
   const selectionEndBlock = getSelectionEndBlock(snapshot)
 
   if (!selectionEndBlock) {
     return undefined
   }
 
-  let foundSelectionEndBlock = false
+  const index = snapshot.blockIndexMap.get(selectionEndBlock.node._key)
 
-  for (const block of snapshot.context.value) {
-    if (block._key === selectionEndBlock.node._key) {
-      foundSelectionEndBlock = true
-      continue
-    }
-
-    if (foundSelectionEndBlock) {
-      nextBlock = {node: block, path: [{_key: block._key}]}
-      break
-    }
+  if (index === undefined || index === snapshot.context.value.length - 1) {
+    return undefined
   }
 
-  if (foundSelectionEndBlock && nextBlock) {
-    return nextBlock
-  }
+  const nextBlock = snapshot.context.value.at(index + 1)
 
-  return undefined
+  return nextBlock
+    ? {node: nextBlock, path: [{_key: nextBlock._key}]}
+    : undefined
 }

package/src/selectors/selector.get-previous-block.ts

@@ -9,27 +9,21 @@ import {getSelectionStartBlock} from './selector.get-selection-start-block'
 export const getPreviousBlock: EditorSelector<
   {node: PortableTextBlock; path: BlockPath} | undefined
 > = (snapshot) => {
-  let previousBlock: {node: PortableTextBlock; path: BlockPath} | undefined
   const selectionStartBlock = getSelectionStartBlock(snapshot)
 
   if (!selectionStartBlock) {
     return undefined
   }
 
-  let foundSelectionStartBlock = false
+  const index = snapshot.blockIndexMap.get(selectionStartBlock.node._key)
 
-  for (const block of snapshot.context.value) {
-    if (block._key === selectionStartBlock.node._key) {
-      foundSelectionStartBlock = true
-      break
-    }
-
-    previousBlock = {node: block, path: [{_key: block._key}]}
+  if (index === undefined || index === 0) {
+    return undefined
   }
 
-  if (foundSelectionStartBlock && previousBlock) {
-    return previousBlock
-  }
+  const previousBlock = snapshot.context.value.at(index - 1)
 
-  return undefined
+  return previousBlock
+    ? {node: previousBlock, path: [{_key: previousBlock._key}]}
+    : undefined
 }

package/src/selectors/selector.get-selected-blocks.ts

@@ -25,7 +25,19 @@ export const getSelectedBlocks: EditorSelector<
     return selectedBlocks
   }
 
-  for (const block of snapshot.context.value) {
+  const startBlockIndex = snapshot.blockIndexMap.get(startKey)
+  const endBlockIndex = snapshot.blockIndexMap.get(endKey)
+
+  if (startBlockIndex === undefined || endBlockIndex === undefined) {
+    return selectedBlocks
+  }
+
+  const slicedValue = snapshot.context.value.slice(
+    startBlockIndex,
+    endBlockIndex + 1,
+  )
+
+  for (const block of slicedValue) {
     if (block._key === startKey) {
       selectedBlocks.push({node: block, path: [{_key: block._key}]})
 

package/src/selectors/selector.get-selected-slice.ts

@@ -1,15 +1,13 @@
 import type {PortableTextBlock} from '@sanity/types'
 import type {EditorSelector} from '../editor/editor-selector'
-import {sliceBlocks} from '../utils'
+import {getSelectedValue} from './selector.get-selected-value'
 
 /**
  * @public
+ * @deprecated Renamed to `getSelectedValue`.
  */
 export const getSelectedSlice: EditorSelector<Array<PortableTextBlock>> = (
   snapshot,
 ) => {
-  return sliceBlocks({
-    context: snapshot.context,
-    blocks: snapshot.context.value,
-  })
+  return getSelectedValue(snapshot)
 }

package/src/selectors/selector.get-selected-spans.ts

@@ -36,17 +36,28 @@ export const getSelectedSpans: EditorSelector<
 
   const startBlockKey = getBlockKeyFromSelectionPoint(startPoint)
   const endBlockKey = getBlockKeyFromSelectionPoint(endPoint)
+  const startSpanKey = getChildKeyFromSelectionPoint(startPoint)
+  const endSpanKey = getChildKeyFromSelectionPoint(endPoint)
 
   if (!startBlockKey || !endBlockKey) {
     return selectedSpans
   }
 
-  const startSpanKey = getChildKeyFromSelectionPoint(startPoint)
-  const endSpanKey = getChildKeyFromSelectionPoint(endPoint)
+  const startBlockIndex = snapshot.blockIndexMap.get(startBlockKey)
+  const endBlockIndex = snapshot.blockIndexMap.get(endBlockKey)
+
+  if (startBlockIndex === undefined || endBlockIndex === undefined) {
+    return selectedSpans
+  }
+
+  const slicedValue = snapshot.context.value.slice(
+    startBlockIndex,
+    endBlockIndex + 1,
+  )
 
   let startBlockFound = false
 
-  for (const block of snapshot.context.value) {
+  for (const block of slicedValue) {
     if (block._key === startBlockKey) {
       startBlockFound = true
     }

package/src/selectors/selector.get-selected-text-blocks.ts

@@ -29,7 +29,19 @@ export const getSelectedTextBlocks: EditorSelector<
     return selectedTextBlocks
   }
 
-  for (const block of snapshot.context.value) {
+  const startBlockIndex = snapshot.blockIndexMap.get(startBlockKey)
+  const endBlockIndex = snapshot.blockIndexMap.get(endBlockKey)
+
+  if (startBlockIndex === undefined || endBlockIndex === undefined) {
+    return selectedTextBlocks
+  }
+
+  const slicedValue = snapshot.context.value.slice(
+    startBlockIndex,
+    endBlockIndex + 1,
+  )
+
+  for (const block of slicedValue) {
     if (block._key === startBlockKey) {
       if (isTextBlock(snapshot.context, block)) {
         selectedTextBlocks.push({node: block, path: [{_key: block._key}]})

package/src/selectors/selector.get-selected-value.ts

@@ -0,0 +1,47 @@
+import type {PortableTextBlock} from '@sanity/types'
+import type {EditorSelector} from '../editor/editor-selector'
+import {getBlockKeyFromSelectionPoint} from '../selection/selection-point'
+import {
+  getSelectionEndPoint,
+  getSelectionStartPoint,
+  sliceBlocks,
+} from '../utils'
+
+/**
+ * @public
+ */
+export const getSelectedValue: EditorSelector<Array<PortableTextBlock>> = (
+  snapshot,
+) => {
+  const selection = snapshot.context.selection
+
+  if (!selection) {
+    return []
+  }
+
+  const startPoint = getSelectionStartPoint(selection)
+  const endPoint = getSelectionEndPoint(selection)
+  const startBlockKey = getBlockKeyFromSelectionPoint(startPoint)
+  const endBlockKey = getBlockKeyFromSelectionPoint(endPoint)
+
+  if (!startBlockKey || !endBlockKey) {
+    return []
+  }
+
+  const startBlockIndex = snapshot.blockIndexMap.get(startBlockKey)
+  const endBlockIndex = snapshot.blockIndexMap.get(endBlockKey)
+
+  if (startBlockIndex === undefined || endBlockIndex === undefined) {
+    return []
+  }
+
+  const slicedValue = snapshot.context.value.slice(
+    startBlockIndex,
+    endBlockIndex + 1,
+  )
+
+  return sliceBlocks({
+    context: snapshot.context,
+    blocks: slicedValue,
+  })
+}

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

@@ -1,14 +1,14 @@
 import type {EditorSelector} from '../editor/editor-selector'
 import {isSpan, isTextBlock} from '../internal-utils/parse-blocks'
-import {getSelectedSlice} from './selector.get-selected-slice'
+import {getSelectedValue} from './selector.get-selected-value'
 
 /**
  * @public
  */
 export const getSelectionText: EditorSelector<string> = (snapshot) => {
-  const selectedSlice = getSelectedSlice(snapshot)
+  const selectedValue = getSelectedValue(snapshot)
 
-  return selectedSlice.reduce((text, block) => {
+  return selectedValue.reduce((text, block) => {
     if (!isTextBlock(snapshot.context, block)) {
       return text
     }

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

@@ -36,6 +36,18 @@ export const getTrimmedSelection: EditorSelector<EditorSelection> = (
     return snapshot.context.selection
   }
 
+  const startBlockIndex = snapshot.blockIndexMap.get(startBlockKey)
+  const endBlockIndex = snapshot.blockIndexMap.get(endBlockKey)
+
+  if (startBlockIndex === undefined || endBlockIndex === undefined) {
+    return snapshot.context.selection
+  }
+
+  const slicedValue = snapshot.context.value.slice(
+    startBlockIndex,
+    endBlockIndex + 1,
+  )
+
   let startBlockFound = false
   let adjustedStartPoint: EditorSelectionPoint | undefined
   let trimStartPoint = false
@@ -45,7 +57,7 @@ export const getTrimmedSelection: EditorSelector<EditorSelection> = (
     | {blockKey: string; span: PortableTextSpan}
     | undefined
 
-  for (const block of snapshot.context.value) {
+  for (const block of slicedValue) {
     if (block._key === startBlockKey) {
       startBlockFound = true