@portabletext/editor 1.57.3 → 1.57.4

package/src/internal-utils/paths.ts

@@ -1,110 +0,0 @@
-import type {Path} from 'slate'
-import type {
-  EditorContext,
-  EditorSelectionPoint,
-  EditorSnapshot,
-  PortableTextBlock,
-  PortableTextObject,
-  PortableTextSpan,
-} from '..'
-import {
-  getBlockKeyFromSelectionPoint,
-  getChildKeyFromSelectionPoint,
-} from '../selection/selection-point'
-import {isSpan, isTextBlock} from './parse-blocks'
-
-export function toSlatePath(
-  snapshot: {
-    context: Pick<EditorContext, 'schema' | 'value'>
-  } & Pick<EditorSnapshot, 'blockIndexMap'>,
-  path: EditorSelectionPoint['path'],
-): {
-  block: PortableTextBlock | undefined
-  child: PortableTextSpan | PortableTextObject | undefined
-  path: Path
-} {
-  const blockKey = getBlockKeyFromSelectionPoint({
-    path,
-    offset: 0,
-  })
-
-  if (!blockKey) {
-    return {
-      block: undefined,
-      child: undefined,
-      path: [],
-    }
-  }
-
-  const blockIndex = snapshot.blockIndexMap.get(blockKey)
-
-  if (blockIndex === undefined) {
-    return {
-      block: undefined,
-      child: undefined,
-      path: [],
-    }
-  }
-
-  const block = snapshot.context.value.at(blockIndex)
-
-  if (!block) {
-    return {
-      block: undefined,
-      child: undefined,
-      path: [],
-    }
-  }
-
-  if (!isTextBlock(snapshot.context, block)) {
-    return {
-      block,
-      child: undefined,
-      path: [blockIndex, 0],
-    }
-  }
-
-  const childKey = getChildKeyFromSelectionPoint({
-    path,
-    offset: 0,
-  })
-
-  if (!childKey) {
-    return {
-      block,
-      child: undefined,
-      path: [blockIndex, 0],
-    }
-  }
-
-  let childPath: Array<number> = []
-  let childIndex = -1
-  let pathChild: PortableTextSpan | PortableTextObject | undefined = undefined
-
-  for (const child of block.children) {
-    childIndex++
-    if (child._key === childKey) {
-      pathChild = child
-      if (isSpan(snapshot.context, child)) {
-        childPath = [childIndex]
-      } else {
-        childPath = [childIndex, 0]
-      }
-      break
-    }
-  }
-
-  if (childPath.length === 0) {
-    return {
-      block,
-      child: undefined,
-      path: [blockIndex, 0],
-    }
-  }
-
-  return {
-    block,
-    child: pathChild,
-    path: [blockIndex].concat(childPath),
-  }
-}

package/src/internal-utils/ranges.ts

@@ -1,70 +0,0 @@
-import {Point, type Operation, type Range} from 'slate'
-import type {EditorContext, EditorSnapshot} from '../editor/editor-snapshot'
-import {isSpan} from './parse-blocks'
-import {toSlatePath} from './paths'
-
-export function toSlateRange(
-  snapshot: {
-    context: Pick<EditorContext, 'schema' | 'value' | 'selection'>
-  } & Pick<EditorSnapshot, 'blockIndexMap'>,
-): Range | null {
-  if (!snapshot.context.selection) {
-    return null
-  }
-
-  const anchorPath = toSlatePath(
-    snapshot,
-    snapshot.context.selection.anchor.path,
-  )
-  const focusPath = toSlatePath(snapshot, snapshot.context.selection.focus.path)
-
-  if (anchorPath.path.length === 0 || focusPath.path.length === 0) {
-    return null
-  }
-
-  const anchorOffset = anchorPath.child
-    ? isSpan(snapshot.context, anchorPath.child)
-      ? Math.min(
-          anchorPath.child.text.length,
-          snapshot.context.selection.anchor.offset,
-        )
-      : 0
-    : 0
-  const focusOffset = focusPath.child
-    ? isSpan(snapshot.context, focusPath.child)
-      ? Math.min(
-          focusPath.child.text.length,
-          snapshot.context.selection.focus.offset,
-        )
-      : 0
-    : 0
-
-  return {
-    anchor: {
-      path: anchorPath.path,
-      offset: anchorOffset,
-    },
-    focus: {
-      path: focusPath.path,
-      offset: focusOffset,
-    },
-  }
-}
-
-export function moveRangeByOperation(
-  range: Range,
-  operation: Operation,
-): Range | null {
-  const anchor = Point.transform(range.anchor, operation)
-  const focus = Point.transform(range.focus, operation)
-
-  if (anchor === null || focus === null) {
-    return null
-  }
-
-  if (Point.equals(anchor, range.anchor) && Point.equals(focus, range.focus)) {
-    return range
-  }
-
-  return {anchor, focus}
-}