@portabletext/editor 1.44.1 → 1.44.3

package/src/internal-utils/paths.ts

@@ -1,42 +1,6 @@
 import {isKeySegment, type Path} from '@sanity/types'
 import {isEqual} from 'lodash'
-import {
-  Editor,
-  Element,
-  type Descendant,
-  type Point,
-  type Path as SlatePath,
-} from 'slate'
-import type {PortableTextMemberSchemaTypes} from '../types/editor'
-import type {ObjectWithKeyAndType} from './ranges'
-
-export function createKeyedPath(
-  point: Point,
-  value: ObjectWithKeyAndType[] | undefined,
-  types: PortableTextMemberSchemaTypes,
-): Path | null {
-  const blockPath = [point.path[0]]
-  if (!value) {
-    return null
-  }
-  const block = value[blockPath[0]]
-  if (!block) {
-    return null
-  }
-  const keyedBlockPath = [{_key: block._key}]
-  if (block._type !== types.block.name) {
-    return keyedBlockPath as Path
-  }
-  let keyedChildPath: Path | undefined
-  const childPath = point.path.slice(0, 2)
-  const child = Array.isArray(block.children) && block.children[childPath[1]]
-  if (child) {
-    keyedChildPath = ['children', {_key: child._key}]
-  }
-  return (
-    keyedChildPath ? [...keyedBlockPath, ...keyedChildPath] : keyedBlockPath
-  ) as Path
-}
+import {Editor, Element, type Descendant, type Path as SlatePath} from 'slate'
 
 export function toSlatePath(path: Path, editor: Editor): SlatePath {
   if (!editor) {

package/src/internal-utils/ranges.ts

@@ -1,10 +1,6 @@
-import {Point, Range, type BaseRange, type Editor, type Operation} from 'slate'
-import type {
-  EditorSelection,
-  EditorSelectionPoint,
-  PortableTextMemberSchemaTypes,
-} from '../types/editor'
-import {createKeyedPath, toSlatePath} from './paths'
+import {Point, type Editor, type Operation, type Range} from 'slate'
+import type {EditorSelection} from '../types/editor'
+import {toSlatePath} from './paths'
 
 export interface ObjectWithKeyAndType {
   _key: string
@@ -12,36 +8,6 @@ export interface ObjectWithKeyAndType {
   children?: ObjectWithKeyAndType[]
 }
 
-export function toPortableTextRange(
-  value: ObjectWithKeyAndType[] | undefined,
-  range: BaseRange | Partial<BaseRange> | null,
-  types: PortableTextMemberSchemaTypes,
-): EditorSelection {
-  if (!range) {
-    return null
-  }
-  let anchor: EditorSelectionPoint | null = null
-  let focus: EditorSelectionPoint | null = null
-  const anchorPath = range.anchor && createKeyedPath(range.anchor, value, types)
-  if (anchorPath && range.anchor) {
-    anchor = {
-      path: anchorPath,
-      offset: range.anchor.offset,
-    }
-  }
-  const focusPath = range.focus && createKeyedPath(range.focus, value, types)
-  if (focusPath && range.focus) {
-    focus = {
-      path: focusPath,
-      offset: range.focus.offset,
-    }
-  }
-  const backward = Boolean(
-    Range.isRange(range) ? Range.isBackward(range) : undefined,
-  )
-  return anchor && focus ? {anchor, focus, backward} : null
-}
-
 export function toSlateRange(
   selection: EditorSelection,
   editor: Editor,

package/src/internal-utils/slate-children-to-blocks.ts

@@ -0,0 +1,49 @@
+import type {PortableTextBlock} from '@sanity/types'
+import type {Descendant} from 'slate'
+import type {EditorSchema} from '../editor/define-schema'
+
+export function slateChildrenToBlocks(
+  schema: EditorSchema,
+  value: Array<Descendant>,
+): Array<PortableTextBlock> {
+  const blocks: Array<PortableTextBlock> = new Array(value.length)
+
+  for (let blockIndex = 0; blockIndex < value.length; blockIndex++) {
+    const descendant = value[blockIndex]
+
+    if (descendant._type !== schema.block.name) {
+      blocks[blockIndex] = {
+        _key: descendant._key,
+        _type: descendant._type,
+        ...('value' in descendant && typeof descendant.value === 'object'
+          ? descendant.value
+          : {}),
+      }
+      continue
+    }
+
+    const children = 'children' in descendant ? descendant.children : []
+    const processedChildren = new Array(children.length)
+
+    for (let childIndex = 0; childIndex < children.length; childIndex++) {
+      const child = children[childIndex]
+      processedChildren[childIndex] =
+        child._type === schema.span.name
+          ? child
+          : {
+              _key: child._key,
+              _type: child._type,
+              ...('value' in child && typeof child.value === 'object'
+                ? child.value
+                : {}),
+            }
+    }
+
+    blocks[blockIndex] = {
+      ...descendant,
+      children: processedChildren,
+    }
+  }
+
+  return blocks
+}

package/src/internal-utils/slate-utils.ts

@@ -1,6 +1,6 @@
-import {Editor, Element, Node, type Path} from 'slate'
+import {Editor, Element, Node, Range, type Path, type Point} from 'slate'
 import type {EditorSchema} from '../editor/define-schema'
-import type {PortableTextSlateEditor} from '../types/editor'
+import type {EditorSelection, PortableTextSlateEditor} from '../types/editor'
 import {fromSlateValue} from './values'
 
 export function getFocusBlock({
@@ -12,14 +12,26 @@ export function getFocusBlock({
     return [undefined, undefined]
   }
 
-  const focusBlock = Array.from(
-    Editor.nodes(editor, {
-      at: editor.selection.focus.path.slice(0, 1),
-      match: (n) => !Editor.isEditor(n),
-    }),
-  ).at(0)
+  return (
+    Editor.node(editor, editor.selection.focus.path.slice(0, 1)) ?? [
+      undefined,
+      undefined,
+    ]
+  )
+}
 
-  return focusBlock ?? [undefined, undefined]
+function getPointBlock({
+  editor,
+  point,
+}: {
+  editor: PortableTextSlateEditor
+  point: Point
+}): [node: Node, path: Path] | [undefined, undefined] {
+  const [block] = Editor.node(editor, point.path.slice(0, 1)) ?? [
+    undefined,
+    undefined,
+  ]
+  return block ? [block, point.path] : [undefined, undefined]
 }
 
 export function getFocusChild({
@@ -41,6 +53,31 @@ export function getFocusChild({
     : [undefined, undefined]
 }
 
+function getPointChild({
+  editor,
+  point,
+}: {
+  editor: PortableTextSlateEditor
+  point: Point
+}): [node: Node, path: Path] | [undefined, undefined] {
+  const [block, blockPath] = getPointBlock({editor, point})
+  const childIndex = point.path.at(1)
+
+  if (!block || !blockPath || childIndex === undefined) {
+    return [undefined, undefined]
+  }
+
+  try {
+    const pointChild = Node.child(block, childIndex)
+
+    return pointChild
+      ? [pointChild, [...blockPath, childIndex]]
+      : [undefined, undefined]
+  } catch {
+    return [undefined, undefined]
+  }
+}
+
 export function getFirstBlock({
   editor,
 }: {
@@ -178,3 +215,65 @@ export function isStyleActive({
 
   return false
 }
+
+export function slateRangeToSelection({
+  schema,
+  editor,
+  range,
+}: {
+  schema: EditorSchema
+  editor: PortableTextSlateEditor
+  range: Range
+}): EditorSelection {
+  const [anchorBlock] = getPointBlock({
+    editor,
+    point: range.anchor,
+  })
+  const [focusBlock] = getPointBlock({
+    editor,
+    point: range.focus,
+  })
+
+  if (!anchorBlock || !focusBlock) {
+    return null
+  }
+
+  const [anchorChild] =
+    anchorBlock._type === schema.block.name
+      ? getPointChild({
+          editor,
+          point: range.anchor,
+        })
+      : [undefined, undefined]
+  const [focusChild] =
+    focusBlock._type === schema.block.name
+      ? getPointChild({
+          editor,
+          point: range.focus,
+        })
+      : [undefined, undefined]
+
+  const selection: EditorSelection = {
+    anchor: {
+      path: [{_key: anchorBlock._key}],
+      offset: range.anchor.offset,
+    },
+    focus: {
+      path: [{_key: focusBlock._key}],
+      offset: range.focus.offset,
+    },
+    backward: Range.isBackward(range),
+  }
+
+  if (anchorChild) {
+    selection.anchor.path.push('children')
+    selection.anchor.path.push({_key: anchorChild._key})
+  }
+
+  if (focusChild) {
+    selection.focus.path.push('children')
+    selection.focus.path.push({_key: focusChild._key})
+  }
+
+  return selection
+}

package/src/type-utils.ts

@@ -25,3 +25,5 @@ export type NamespaceEvent<TEvent, TNamespace extends string> = TEvent extends {
         : TEvent[K]
     }
   : never
+
+export type StrictExtract<T, U extends T> = U

package/src/behavior-actions/behavior.action.move.block-down.ts

@@ -1,48 +0,0 @@
-import {Path} from 'slate'
-import {toSlatePath} from '../internal-utils/paths'
-import {toPortableTextRange} from '../internal-utils/ranges'
-import {isKeyedSegment} from '../utils'
-import {moveBlockActionImplementation} from './behavior.action.move.block'
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const moveBlockDownActionImplementation: BehaviorActionImplementation<
-  'move.block down'
-> = ({context, action}) => {
-  const at = [toSlatePath(action.at, action.editor)[0]]
-  const to = [Path.next(at)[0]]
-  const selection = toPortableTextRange(
-    action.editor.children,
-    {
-      anchor: {
-        path: to,
-        offset: 0,
-      },
-      focus: {
-        path: to,
-        offset: 0,
-      },
-    },
-    context.schema,
-  )
-
-  const destinationBlockKey = selection
-    ? isKeyedSegment(selection.focus.path[0])
-      ? selection.focus.path[0]._key
-      : undefined
-    : undefined
-
-  if (destinationBlockKey === undefined) {
-    console.error('Could not find destination block key')
-    return
-  }
-
-  moveBlockActionImplementation({
-    context,
-    action: {
-      type: 'move.block',
-      at: action.at,
-      to: [{_key: destinationBlockKey}],
-      editor: action.editor,
-    },
-  })
-}

package/src/behavior-actions/behavior.action.move.block-up.ts

@@ -1,53 +0,0 @@
-import {Path} from 'slate'
-import {toSlatePath} from '../internal-utils/paths'
-import {toPortableTextRange} from '../internal-utils/ranges'
-import {isKeyedSegment} from '../utils'
-import {moveBlockActionImplementation} from './behavior.action.move.block'
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const moveBlockUpActionImplementation: BehaviorActionImplementation<
-  'move.block up'
-> = ({context, action}) => {
-  const at = [toSlatePath(action.at, action.editor)[0]]
-
-  if (!Path.hasPrevious(at)) {
-    return
-  }
-
-  const to = [Path.previous(at)[0]]
-  const selection = toPortableTextRange(
-    action.editor.children,
-    {
-      anchor: {
-        path: to,
-        offset: 0,
-      },
-      focus: {
-        path: to,
-        offset: 0,
-      },
-    },
-    context.schema,
-  )
-
-  const destinationBlockKey = selection
-    ? isKeyedSegment(selection.focus.path[0])
-      ? selection.focus.path[0]._key
-      : undefined
-    : undefined
-
-  if (destinationBlockKey === undefined) {
-    console.error('Could not find destination block key')
-    return
-  }
-
-  moveBlockActionImplementation({
-    context,
-    action: {
-      type: 'move.block',
-      at: action.at,
-      to: [{_key: destinationBlockKey}],
-      editor: action.editor,
-    },
-  })
-}