@portabletext/editor 3.3.3 → 3.3.4

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

@@ -1,263 +0,0 @@
-import type {EditorSelector} from '../editor/editor-selector'
-import {isBlockPath} from '../types/paths'
-import {blockOffsetToSpanSelectionPoint} from '../utils/util.block-offset'
-import {isSelectionExpanded} from '../utils/util.is-selection-expanded'
-import {getFocusSpan} from './selector.get-focus-span'
-import {getFocusTextBlock} from './selector.get-focus-text-block'
-import {getNextSpan} from './selector.get-next-span'
-import {getPreviousSpan} from './selector.get-previous-span'
-import {getSelectedSpans} from './selector.get-selected-spans'
-
-/**
- * @beta
- */
-export type MarkState =
-  | {
-      state: 'unchanged'
-      marks: Array<string>
-    }
-  | {
-      state: 'changed'
-      marks: Array<string>
-      previousMarks: Array<string>
-    }
-
-/**
- * Given that text is inserted at the current position, what marks should
- * be applied?
- * @beta
- */
-export const getMarkState: EditorSelector<MarkState | undefined> = (
-  snapshot,
-) => {
-  if (!snapshot.context.selection) {
-    return undefined
-  }
-
-  let selection = snapshot.context.selection
-  const focusTextBlock = getFocusTextBlock(snapshot)
-
-  if (!focusTextBlock) {
-    return undefined
-  }
-
-  if (isBlockPath(selection.anchor.path)) {
-    const spanSelectionPoint = blockOffsetToSpanSelectionPoint({
-      context: snapshot.context,
-      blockOffset: {
-        path: selection.anchor.path,
-        offset: selection.anchor.offset,
-      },
-      direction: selection.backward ? 'backward' : 'forward',
-    })
-
-    selection = spanSelectionPoint
-      ? {
-          ...selection,
-          anchor: spanSelectionPoint,
-        }
-      : selection
-  }
-
-  if (isBlockPath(selection.focus.path)) {
-    const spanSelectionPoint = blockOffsetToSpanSelectionPoint({
-      context: snapshot.context,
-      blockOffset: {
-        path: selection.focus.path,
-        offset: selection.focus.offset,
-      },
-      direction: selection.backward ? 'backward' : 'forward',
-    })
-
-    selection = spanSelectionPoint
-      ? {
-          ...selection,
-          focus: spanSelectionPoint,
-        }
-      : selection
-  }
-
-  const focusSpan = getFocusSpan({
-    ...snapshot,
-    context: {
-      ...snapshot.context,
-      selection,
-    },
-  })
-
-  if (!focusSpan) {
-    return undefined
-  }
-
-  if (isSelectionExpanded(selection)) {
-    const selectedSpans = getSelectedSpans({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection,
-      },
-    })
-
-    let index = 0
-    let marks: Array<string> = []
-
-    for (const span of selectedSpans) {
-      if (index === 0) {
-        marks = span.node.marks ?? []
-      } else {
-        if (span.node.marks?.length === 0) {
-          marks = []
-          continue
-        }
-
-        marks = marks.filter((mark) =>
-          (span.node.marks ?? []).some((spanMark) => spanMark === mark),
-        )
-      }
-
-      index++
-    }
-
-    return {
-      state: 'unchanged',
-      marks,
-    }
-  }
-
-  const decorators = snapshot.context.schema.decorators.map(
-    (decorator) => decorator.name,
-  )
-  const marks = focusSpan.node.marks ?? []
-  const marksWithoutAnnotations = marks.filter((mark) =>
-    decorators.includes(mark),
-  )
-
-  const spanHasAnnotations = marks.length > marksWithoutAnnotations.length
-
-  const spanIsEmpty = focusSpan.node.text.length === 0
-
-  const atTheBeginningOfSpan = snapshot.context.selection.anchor.offset === 0
-  const atTheEndOfSpan =
-    snapshot.context.selection.anchor.offset === focusSpan.node.text.length
-
-  const previousSpan = getPreviousSpan({
-    ...snapshot,
-    context: {
-      ...snapshot.context,
-      selection,
-    },
-  })
-  const nextSpan = getNextSpan({
-    ...snapshot,
-    context: {
-      ...snapshot.context,
-      selection,
-    },
-  })
-  const nextSpanAnnotations =
-    nextSpan?.node?.marks?.filter((mark) => !decorators.includes(mark)) ?? []
-  const spanAnnotations = marks.filter((mark) => !decorators.includes(mark))
-
-  const previousSpanHasAnnotations = previousSpan
-    ? previousSpan.node.marks?.some((mark) => !decorators.includes(mark))
-    : false
-  const previousSpanHasSameAnnotations = previousSpan
-    ? previousSpan.node.marks
-        ?.filter((mark) => !decorators.includes(mark))
-        .every((mark) => marks.includes(mark))
-    : false
-  const previousSpanHasSameAnnotation = previousSpan
-    ? previousSpan.node.marks?.some(
-        (mark) => !decorators.includes(mark) && marks.includes(mark),
-      )
-    : false
-
-  const previousSpanHasSameMarks = previousSpan
-    ? previousSpan.node.marks?.every((mark) => marks.includes(mark))
-    : false
-  const nextSpanSharesSomeAnnotations = spanAnnotations.some((mark) =>
-    nextSpanAnnotations?.includes(mark),
-  )
-
-  if (spanHasAnnotations && !spanIsEmpty) {
-    if (atTheBeginningOfSpan) {
-      if (previousSpanHasSameMarks) {
-        return {
-          state: 'changed',
-          previousMarks: marks,
-          marks: previousSpan?.node.marks ?? [],
-        }
-      } else if (previousSpanHasSameAnnotations) {
-        return {
-          state: 'changed',
-          previousMarks: marks,
-          marks: previousSpan?.node.marks ?? [],
-        }
-      } else if (previousSpanHasSameAnnotation) {
-        return {
-          state: 'unchanged',
-          marks: focusSpan.node.marks ?? [],
-        }
-      } else if (!previousSpan) {
-        return {
-          state: 'changed',
-          previousMarks: marks,
-          marks: [],
-        }
-      }
-    }
-
-    if (atTheEndOfSpan) {
-      if (!nextSpan) {
-        return {
-          state: 'changed',
-          previousMarks: marks,
-          marks: [],
-        }
-      }
-
-      if (nextSpanAnnotations.length > 0 && !nextSpanSharesSomeAnnotations) {
-        return {
-          state: 'changed',
-          previousMarks: marks,
-          marks: [],
-        }
-      }
-
-      if (
-        (nextSpanSharesSomeAnnotations &&
-          nextSpanAnnotations.length < spanAnnotations.length) ||
-        !nextSpanSharesSomeAnnotations
-      ) {
-        return {
-          state: 'changed',
-          previousMarks: marks,
-          marks: nextSpan?.node.marks ?? [],
-        }
-      }
-    }
-  }
-
-  if (atTheBeginningOfSpan && !spanIsEmpty && !!previousSpan) {
-    if (previousSpanHasAnnotations) {
-      return {
-        state: 'changed',
-        marks,
-        previousMarks: previousSpan?.node.marks ?? [],
-      }
-    } else {
-      return {
-        state: 'changed',
-        previousMarks: marks,
-        marks: (previousSpan?.node.marks ?? []).filter((mark) =>
-          decorators.includes(mark),
-        ),
-      }
-    }
-  }
-
-  return {
-    state: 'unchanged',
-    marks,
-  }
-}

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

@@ -1,29 +0,0 @@
-import type {PortableTextBlock} from '@sanity/types'
-import type {EditorSelector} from '../editor/editor-selector'
-import type {BlockPath} from '../types/paths'
-import {getSelectionEndBlock} from './selector.get-selection-end-block'
-
-/**
- * @public
- */
-export const getNextBlock: EditorSelector<
-  {node: PortableTextBlock; path: BlockPath} | undefined
-> = (snapshot) => {
-  const selectionEndBlock = getSelectionEndBlock(snapshot)
-
-  if (!selectionEndBlock) {
-    return undefined
-  }
-
-  const index = snapshot.blockIndexMap.get(selectionEndBlock.node._key)
-
-  if (index === undefined || index === snapshot.context.value.length - 1) {
-    return undefined
-  }
-
-  const nextBlock = snapshot.context.value.at(index + 1)
-
-  return nextBlock
-    ? {node: nextBlock, path: [{_key: nextBlock._key}]}
-    : undefined
-}

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

@@ -1,53 +0,0 @@
-import {isSpan} from '@portabletext/schema'
-import {isKeySegment, type PortableTextObject} from '@sanity/types'
-import type {EditorSelector} from '../editor/editor-selector'
-import type {ChildPath} from '../types/paths'
-import {getFocusTextBlock} from './selector.get-focus-text-block'
-import {getSelectionEndPoint} from './selector.get-selection-end-point'
-
-/**
- * @public
- */
-export const getNextInlineObject: EditorSelector<
-  | {
-      node: PortableTextObject
-      path: ChildPath
-    }
-  | undefined
-> = (snapshot) => {
-  const focusTextBlock = getFocusTextBlock(snapshot)
-  const selectionEndPoint = getSelectionEndPoint(snapshot)
-  const selectionEndPointChildKey =
-    selectionEndPoint && isKeySegment(selectionEndPoint.path[2])
-      ? selectionEndPoint.path[2]._key
-      : undefined
-
-  if (!focusTextBlock || !selectionEndPointChildKey) {
-    return undefined
-  }
-
-  let endPointChildFound = false
-  let inlineObject:
-    | {
-        node: PortableTextObject
-        path: ChildPath
-      }
-    | undefined
-
-  for (const child of focusTextBlock.node.children) {
-    if (child._key === selectionEndPointChildKey) {
-      endPointChildFound = true
-      continue
-    }
-
-    if (!isSpan(snapshot.context, child) && endPointChildFound) {
-      inlineObject = {
-        node: child,
-        path: [...focusTextBlock.path, 'children', {_key: child._key}],
-      }
-      break
-    }
-  }
-
-  return inlineObject
-}

package/src/selectors/selector.get-next-inline-objects.ts

@@ -1,50 +0,0 @@
-import {isSpan} from '@portabletext/schema'
-import {isKeySegment, type PortableTextObject} from '@sanity/types'
-import type {EditorSelector} from '../editor/editor-selector'
-import type {ChildPath} from '../types/paths'
-import {getFocusTextBlock} from './selector.get-focus-text-block'
-import {getSelectionEndPoint} from './selector.get-selection-end-point'
-
-/**
- * @public
- */
-export const getNextInlineObjects: EditorSelector<
-  Array<{
-    node: PortableTextObject
-    path: ChildPath
-  }>
-> = (snapshot) => {
-  const focusTextBlock = getFocusTextBlock(snapshot)
-  const selectionEndPoint = getSelectionEndPoint(snapshot)
-  const selectionEndPointChildKey =
-    selectionEndPoint && isKeySegment(selectionEndPoint.path[2])
-      ? selectionEndPoint.path[2]._key
-      : undefined
-
-  if (!focusTextBlock || !selectionEndPointChildKey) {
-    return []
-  }
-
-  let endPointChildFound = false
-  const inlineObjects: Array<{
-    node: PortableTextObject
-    path: ChildPath
-  }> = []
-
-  for (const child of focusTextBlock.node.children) {
-    if (child._key === selectionEndPointChildKey) {
-      endPointChildFound = true
-      continue
-    }
-
-    if (!isSpan(snapshot.context, child) && endPointChildFound) {
-      inlineObjects.push({
-        node: child,
-        path: [...focusTextBlock.path, 'children', {_key: child._key}],
-      })
-      break
-    }
-  }
-
-  return inlineObjects
-}

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

@@ -1,56 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {KeyedSegment, PortableTextSpan} from '@sanity/types'
-import type {EditorSelector} from '../editor/editor-selector'
-import {getChildKeyFromSelectionPoint} from '../utils/util.selection-point'
-import {getSelectionEndBlock} from './selector.get-selection-end-block'
-import {getSelectionEndPoint} from './selector.get-selection-end-point'
-
-/**
- * @public
- */
-export const getNextSpan: EditorSelector<
-  | {
-      node: PortableTextSpan
-      path: [KeyedSegment, 'children', KeyedSegment]
-    }
-  | undefined
-> = (snapshot) => {
-  const selectionEndBlock = getSelectionEndBlock(snapshot)
-  const selectionEndPoint = getSelectionEndPoint(snapshot)
-
-  if (!selectionEndBlock || !selectionEndPoint) {
-    return undefined
-  }
-
-  if (!isTextBlock(snapshot.context, selectionEndBlock.node)) {
-    return undefined
-  }
-
-  const selectionEndPointChildKey =
-    getChildKeyFromSelectionPoint(selectionEndPoint)
-
-  let endPointChildFound = false
-  let nextSpan:
-    | {
-        node: PortableTextSpan
-        path: [KeyedSegment, 'children', KeyedSegment]
-      }
-    | undefined
-
-  for (const child of selectionEndBlock.node.children) {
-    if (child._key === selectionEndPointChildKey) {
-      endPointChildFound = true
-      continue
-    }
-
-    if (isSpan(snapshot.context, child) && endPointChildFound) {
-      nextSpan = {
-        node: child,
-        path: [...selectionEndBlock.path, 'children', {_key: child._key}],
-      }
-      break
-    }
-  }
-
-  return nextSpan
-}

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

@@ -1,29 +0,0 @@
-import type {PortableTextBlock} from '@sanity/types'
-import type {EditorSelector} from '../editor/editor-selector'
-import type {BlockPath} from '../types/paths'
-import {getSelectionStartBlock} from './selector.get-selection-start-block'
-
-/**
- * @public
- */
-export const getPreviousBlock: EditorSelector<
-  {node: PortableTextBlock; path: BlockPath} | undefined
-> = (snapshot) => {
-  const selectionStartBlock = getSelectionStartBlock(snapshot)
-
-  if (!selectionStartBlock) {
-    return undefined
-  }
-
-  const index = snapshot.blockIndexMap.get(selectionStartBlock.node._key)
-
-  if (index === undefined || index === 0) {
-    return undefined
-  }
-
-  const previousBlock = snapshot.context.value.at(index - 1)
-
-  return previousBlock
-    ? {node: previousBlock, path: [{_key: previousBlock._key}]}
-    : undefined
-}

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

@@ -1,50 +0,0 @@
-import {isSpan} from '@portabletext/schema'
-import {isKeySegment, type PortableTextObject} from '@sanity/types'
-import type {EditorSelector} from '../editor/editor-selector'
-import type {ChildPath} from '../types/paths'
-import {getFocusTextBlock} from './selector.get-focus-text-block'
-import {getSelectionStartPoint} from './selector.get-selection-start-point'
-
-/**
- * @public
- */
-export const getPreviousInlineObject: EditorSelector<
-  | {
-      node: PortableTextObject
-      path: ChildPath
-    }
-  | undefined
-> = (snapshot) => {
-  const focusTextBlock = getFocusTextBlock(snapshot)
-  const selectionStartPoint = getSelectionStartPoint(snapshot)
-  const selectionStartPointChildKey =
-    selectionStartPoint && isKeySegment(selectionStartPoint.path[2])
-      ? selectionStartPoint.path[2]._key
-      : undefined
-
-  if (!focusTextBlock || !selectionStartPointChildKey) {
-    return undefined
-  }
-
-  let inlineObject:
-    | {
-        node: PortableTextObject
-        path: ChildPath
-      }
-    | undefined
-
-  for (const child of focusTextBlock.node.children) {
-    if (child._key === selectionStartPointChildKey) {
-      break
-    }
-
-    if (!isSpan(snapshot.context, child)) {
-      inlineObject = {
-        node: child,
-        path: [...focusTextBlock.path, 'children', {_key: child._key}],
-      }
-    }
-  }
-
-  return inlineObject
-}

package/src/selectors/selector.get-previous-inline-objects.ts

@@ -1,47 +0,0 @@
-import {isSpan} from '@portabletext/schema'
-import {isKeySegment, type PortableTextObject} from '@sanity/types'
-import type {EditorSelector} from '../editor/editor-selector'
-import type {ChildPath} from '../types/paths'
-import {getFocusTextBlock} from './selector.get-focus-text-block'
-import {getSelectionStartPoint} from './selector.get-selection-start-point'
-
-/**
- * @public
- */
-export const getPreviousInlineObjects: EditorSelector<
-  Array<{
-    node: PortableTextObject
-    path: ChildPath
-  }>
-> = (snapshot) => {
-  const focusTextBlock = getFocusTextBlock(snapshot)
-  const selectionStartPoint = getSelectionStartPoint(snapshot)
-  const selectionStartPointChildKey =
-    selectionStartPoint && isKeySegment(selectionStartPoint.path[2])
-      ? selectionStartPoint.path[2]._key
-      : undefined
-
-  if (!focusTextBlock || !selectionStartPointChildKey) {
-    return []
-  }
-
-  const inlineObjects: Array<{
-    node: PortableTextObject
-    path: ChildPath
-  }> = []
-
-  for (const child of focusTextBlock.node.children) {
-    if (child._key === selectionStartPointChildKey) {
-      break
-    }
-
-    if (!isSpan(snapshot.context, child)) {
-      inlineObjects.push({
-        node: child,
-        path: [...focusTextBlock.path, 'children', {_key: child._key}],
-      })
-    }
-  }
-
-  return inlineObjects
-}

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

@@ -1,53 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {KeyedSegment, PortableTextSpan} from '@sanity/types'
-import type {EditorSelector} from '../editor/editor-selector'
-import {getChildKeyFromSelectionPoint} from '../utils/util.selection-point'
-import {getSelectionStartBlock} from './selector.get-selection-start-block'
-import {getSelectionStartPoint} from './selector.get-selection-start-point'
-
-/**
- * @public
- */
-export const getPreviousSpan: EditorSelector<
-  | {
-      node: PortableTextSpan
-      path: [KeyedSegment, 'children', KeyedSegment]
-    }
-  | undefined
-> = (snapshot) => {
-  const selectionStartBlock = getSelectionStartBlock(snapshot)
-  const selectionStartPoint = getSelectionStartPoint(snapshot)
-
-  if (!selectionStartBlock || !selectionStartPoint) {
-    return undefined
-  }
-
-  if (!isTextBlock(snapshot.context, selectionStartBlock.node)) {
-    return undefined
-  }
-
-  const selectionStartPointChildKey =
-    getChildKeyFromSelectionPoint(selectionStartPoint)
-
-  let previousSpan:
-    | {
-        node: PortableTextSpan
-        path: [KeyedSegment, 'children', KeyedSegment]
-      }
-    | undefined
-
-  for (const child of selectionStartBlock.node.children) {
-    if (child._key === selectionStartPointChildKey) {
-      break
-    }
-
-    if (isSpan(snapshot.context, child)) {
-      previousSpan = {
-        node: child,
-        path: [...selectionStartBlock.path, 'children', {_key: child._key}],
-      }
-    }
-  }
-
-  return previousSpan
-}

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

@@ -1,61 +0,0 @@
-import type {PortableTextBlock} from '@sanity/types'
-import type {EditorSelector} from '../editor/editor-selector'
-import type {BlockPath} from '../types/paths'
-import {getSelectionEndPoint} from '../utils/util.get-selection-end-point'
-import {getSelectionStartPoint} from '../utils/util.get-selection-start-point'
-import {getBlockKeyFromSelectionPoint} from '../utils/util.selection-point'
-
-/**
- * @public
- */
-export const getSelectedBlocks: EditorSelector<
-  Array<{node: PortableTextBlock; path: BlockPath}>
-> = (snapshot) => {
-  if (!snapshot.context.selection) {
-    return []
-  }
-
-  const selectedBlocks: Array<{node: PortableTextBlock; path: BlockPath}> = []
-  const startPoint = getSelectionStartPoint(snapshot.context.selection)
-  const endPoint = getSelectionEndPoint(snapshot.context.selection)
-  const startKey = getBlockKeyFromSelectionPoint(startPoint)
-  const endKey = getBlockKeyFromSelectionPoint(endPoint)
-
-  if (!startKey || !endKey) {
-    return selectedBlocks
-  }
-
-  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}]})
-
-      if (startKey === endKey) {
-        break
-      }
-      continue
-    }
-
-    if (block._key === endKey) {
-      selectedBlocks.push({node: block, path: [{_key: block._key}]})
-      break
-    }
-
-    if (selectedBlocks.length > 0) {
-      selectedBlocks.push({node: block, path: [{_key: block._key}]})
-    }
-  }
-
-  return selectedBlocks
-}