@portabletext/editor 3.3.3 → 3.3.4

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

@@ -1,99 +0,0 @@
-import {Editor, Node, Range, Text, Transforms} from 'slate'
-import {parseAnnotation} from '../utils/parse-blocks'
-import type {BehaviorOperationImplementation} from './behavior.operations'
-
-export const addAnnotationOperationImplementation: BehaviorOperationImplementation<
-  'annotation.add'
-> = ({context, operation}) => {
-  const parsedAnnotation = parseAnnotation({
-    annotation: {
-      _type: operation.annotation.name,
-      _key: operation.annotation._key,
-      ...operation.annotation.value,
-    },
-    context,
-    options: {validateFields: true},
-  })
-
-  if (!parsedAnnotation) {
-    throw new Error(
-      `Failed to parse annotation ${JSON.stringify(operation.annotation)}`,
-    )
-  }
-
-  const editor = operation.editor
-
-  if (!editor.selection || Range.isCollapsed(editor.selection)) {
-    return
-  }
-
-  const selectedBlocks = Editor.nodes(editor, {
-    at: editor.selection,
-    match: (node) => editor.isTextBlock(node),
-    reverse: Range.isBackward(editor.selection),
-  })
-
-  let blockIndex = 0
-
-  for (const [block, blockPath] of selectedBlocks) {
-    if (block.children.length === 0) {
-      continue
-    }
-
-    if (block.children.length === 1 && block.children[0].text === '') {
-      continue
-    }
-
-    // Make sure we don't generate more keys than needed
-    const annotationKey =
-      blockIndex === 0 ? parsedAnnotation._key : context.keyGenerator()
-    const markDefs = block.markDefs ?? []
-    const existingMarkDef = markDefs.find(
-      (markDef) =>
-        markDef._type === parsedAnnotation._type &&
-        markDef._key === annotationKey,
-    )
-
-    if (existingMarkDef === undefined) {
-      Transforms.setNodes(
-        editor,
-        {
-          markDefs: [
-            ...markDefs,
-            {
-              ...parsedAnnotation,
-              _key: annotationKey,
-            },
-          ],
-        },
-        {at: blockPath},
-      )
-    }
-
-    Transforms.setNodes(editor, {}, {match: Text.isText, split: true})
-
-    const children = Node.children(editor, blockPath)
-
-    for (const [span, path] of children) {
-      if (!editor.isTextSpan(span)) {
-        continue
-      }
-
-      if (!Range.includes(editor.selection, path)) {
-        continue
-      }
-
-      const marks = span.marks ?? []
-
-      Transforms.setNodes(
-        editor,
-        {
-          marks: [...marks, annotationKey],
-        },
-        {at: path},
-      )
-    }
-
-    blockIndex++
-  }
-}

package/src/operations/behavior.operation.annotation.remove.ts

@@ -1,150 +0,0 @@
-import type {PortableTextSpan} from '@sanity/types'
-import {Editor, Node, Path, Range, Transforms} from 'slate'
-import type {BehaviorOperationImplementation} from './behavior.operations'
-
-export const removeAnnotationOperationImplementation: BehaviorOperationImplementation<
-  'annotation.remove'
-> = ({operation}) => {
-  const editor = operation.editor
-
-  if (!editor.selection) {
-    return
-  }
-
-  if (Range.isCollapsed(editor.selection)) {
-    const [block, blockPath] = Editor.node(editor, editor.selection, {
-      depth: 1,
-    })
-
-    if (!editor.isTextBlock(block)) {
-      return
-    }
-
-    const markDefs = block.markDefs ?? []
-    const potentialAnnotations = markDefs.filter(
-      (markDef) => markDef._type === operation.annotation.name,
-    )
-
-    const [selectedChild, selectedChildPath] = Editor.node(
-      editor,
-      editor.selection,
-      {
-        depth: 2,
-      },
-    )
-
-    if (!editor.isTextSpan(selectedChild)) {
-      return
-    }
-
-    const annotationToRemove = selectedChild.marks?.find((mark) =>
-      potentialAnnotations.some((markDef) => markDef._key === mark),
-    )
-
-    if (!annotationToRemove) {
-      return
-    }
-
-    const previousSpansWithSameAnnotation: Array<
-      [span: PortableTextSpan, path: Path]
-    > = []
-
-    for (const [child, childPath] of Node.children(editor, blockPath, {
-      reverse: true,
-    })) {
-      if (!editor.isTextSpan(child)) {
-        continue
-      }
-
-      if (!Path.isBefore(childPath, selectedChildPath)) {
-        continue
-      }
-
-      if (child.marks?.includes(annotationToRemove)) {
-        previousSpansWithSameAnnotation.push([child, childPath])
-      } else {
-        break
-      }
-    }
-
-    const nextSpansWithSameAnnotation: Array<
-      [span: PortableTextSpan, path: Path]
-    > = []
-
-    for (const [child, childPath] of Node.children(editor, blockPath)) {
-      if (!editor.isTextSpan(child)) {
-        continue
-      }
-
-      if (!Path.isAfter(childPath, selectedChildPath)) {
-        continue
-      }
-
-      if (child.marks?.includes(annotationToRemove)) {
-        nextSpansWithSameAnnotation.push([child, childPath])
-      } else {
-        break
-      }
-    }
-
-    for (const [child, childPath] of [
-      ...previousSpansWithSameAnnotation,
-      [selectedChild, selectedChildPath] as const,
-      ...nextSpansWithSameAnnotation,
-    ]) {
-      Transforms.setNodes(
-        editor,
-        {
-          marks: child.marks?.filter((mark) => mark !== annotationToRemove),
-        },
-        {at: childPath},
-      )
-    }
-  } else {
-    Transforms.setNodes(
-      editor,
-      {},
-      {
-        match: (node) => editor.isTextSpan(node),
-        split: true,
-        hanging: true,
-      },
-    )
-
-    const blocks = Editor.nodes(editor, {
-      at: editor.selection,
-      match: (node) => editor.isTextBlock(node),
-    })
-
-    for (const [block, blockPath] of blocks) {
-      const children = Node.children(editor, blockPath)
-
-      for (const [child, childPath] of children) {
-        if (!editor.isTextSpan(child)) {
-          continue
-        }
-
-        if (!Range.includes(editor.selection, childPath)) {
-          continue
-        }
-
-        const markDefs = block.markDefs ?? []
-        const marks = child.marks ?? []
-        const marksWithoutAnnotation = marks.filter((mark) => {
-          const markDef = markDefs.find((markDef) => markDef._key === mark)
-          return markDef?._type !== operation.annotation.name
-        })
-
-        if (marksWithoutAnnotation.length !== marks.length) {
-          Transforms.setNodes(
-            editor,
-            {
-              marks: marksWithoutAnnotation,
-            },
-            {at: childPath},
-          )
-        }
-      }
-    }
-  }
-}

package/src/operations/behavior.operation.block.set.ts

@@ -1,104 +0,0 @@
-import {applyAll, set} from '@portabletext/patches'
-import {isTextBlock} from '@portabletext/schema'
-import {Transforms, type Node} from 'slate'
-import {parseMarkDefs} from '../utils/parse-blocks'
-import type {BehaviorOperationImplementation} from './behavior.operations'
-
-export const blockSetOperationImplementation: BehaviorOperationImplementation<
-  'block.set'
-> = ({context, operation}) => {
-  const blockIndex = operation.editor.blockIndexMap.get(operation.at[0]._key)
-
-  if (blockIndex === undefined) {
-    throw new Error(
-      `Unable to find block index for block at ${JSON.stringify(operation.at)}`,
-    )
-  }
-
-  const slateBlock = operation.editor.children.at(blockIndex)
-
-  if (!slateBlock) {
-    throw new Error(`Unable to find block at ${JSON.stringify(operation.at)}`)
-  }
-
-  if (isTextBlock(context, slateBlock)) {
-    const filteredProps: Record<string, unknown> = {}
-
-    for (const key of Object.keys(operation.props)) {
-      if (key === '_type' || key === 'children') {
-        continue
-      }
-
-      if (key === 'style') {
-        if (
-          context.schema.styles.some(
-            (style) => style.name === operation.props[key],
-          )
-        ) {
-          filteredProps[key] = operation.props[key]
-        }
-        continue
-      }
-
-      if (key === 'listItem') {
-        if (
-          context.schema.lists.some(
-            (list) => list.name === operation.props[key],
-          )
-        ) {
-          filteredProps[key] = operation.props[key]
-        }
-        continue
-      }
-
-      if (key === 'level') {
-        filteredProps[key] = operation.props[key]
-        continue
-      }
-
-      if (key === 'markDefs') {
-        const {markDefs} = parseMarkDefs({
-          context,
-          markDefs: operation.props[key],
-          options: {validateFields: true},
-        })
-        filteredProps[key] = markDefs
-        continue
-      }
-
-      if (context.schema.block.fields?.some((field) => field.name === key)) {
-        filteredProps[key] = operation.props[key]
-      }
-    }
-
-    Transforms.setNodes(operation.editor, filteredProps, {at: [blockIndex]})
-  } else {
-    const schemaDefinition = context.schema.blockObjects.find(
-      (definition) => definition.name === slateBlock._type,
-    )
-    const filteredProps: Record<string, unknown> = {}
-
-    for (const key of Object.keys(operation.props)) {
-      if (key === '_type') {
-        continue
-      }
-
-      if (key === '_key') {
-        filteredProps[key] = operation.props[key]
-        continue
-      }
-
-      if (schemaDefinition?.fields.some((field) => field.name === key)) {
-        filteredProps[key] = operation.props[key]
-      }
-    }
-
-    const patches = Object.entries(filteredProps).map(([key, value]) =>
-      key === '_key' ? set(value, ['_key']) : set(value, ['value', key]),
-    )
-
-    const updatedSlateBlock = applyAll(slateBlock, patches) as Partial<Node>
-
-    Transforms.setNodes(operation.editor, updatedSlateBlock, {at: [blockIndex]})
-  }
-}

package/src/operations/behavior.operation.block.unset.ts

@@ -1,54 +0,0 @@
-import {applyAll, set, unset} from '@portabletext/patches'
-import {isTextBlock} from '@portabletext/schema'
-import {Transforms, type Node} from 'slate'
-import type {BehaviorOperationImplementation} from './behavior.operations'
-
-export const blockUnsetOperationImplementation: BehaviorOperationImplementation<
-  'block.unset'
-> = ({context, operation}) => {
-  const blockKey = operation.at[0]._key
-  const blockIndex = operation.editor.blockIndexMap.get(blockKey)
-
-  if (blockIndex === undefined) {
-    throw new Error(`Unable to find block index for block key ${blockKey}`)
-  }
-
-  const slateBlock =
-    blockIndex !== undefined
-      ? operation.editor.children.at(blockIndex)
-      : undefined
-
-  if (!slateBlock) {
-    throw new Error(`Unable to find block at ${JSON.stringify(operation.at)}`)
-  }
-
-  if (isTextBlock(context, slateBlock)) {
-    const propsToRemove = operation.props.filter(
-      (prop) => prop !== '_type' && prop !== '_key' && prop !== 'children',
-    )
-
-    Transforms.unsetNodes(operation.editor, propsToRemove, {at: [blockIndex]})
-
-    if (operation.props.includes('_key')) {
-      Transforms.setNodes(
-        operation.editor,
-        {_key: context.keyGenerator()},
-        {at: [blockIndex]},
-      )
-    }
-
-    return
-  }
-
-  const patches = operation.props.flatMap((key) =>
-    key === '_type'
-      ? []
-      : key === '_key'
-        ? set(context.keyGenerator(), ['_key'])
-        : unset(['value', key]),
-  )
-
-  const updatedSlateBlock = applyAll(slateBlock, patches) as Partial<Node>
-
-  Transforms.setNodes(operation.editor, updatedSlateBlock, {at: [blockIndex]})
-}

package/src/operations/behavior.operation.child.set.ts

@@ -1,107 +0,0 @@
-import {Editor, Element, Transforms} from 'slate'
-import {toSlateRange} from '../internal-utils/to-slate-range'
-import type {BehaviorOperationImplementation} from './behavior.operations'
-
-export const childSetOperationImplementation: BehaviorOperationImplementation<
-  'child.set'
-> = ({context, operation}) => {
-  const location = toSlateRange({
-    context: {
-      schema: context.schema,
-      value: operation.editor.value,
-      selection: {
-        anchor: {path: operation.at, offset: 0},
-        focus: {path: operation.at, offset: 0},
-      },
-    },
-    blockIndexMap: operation.editor.blockIndexMap,
-  })
-
-  if (!location) {
-    throw new Error(
-      `Unable to convert ${JSON.stringify(operation.at)} into a Slate Range`,
-    )
-  }
-
-  const childEntry = Editor.node(operation.editor, location, {depth: 2})
-  const child = childEntry?.[0]
-  const childPath = childEntry?.[1]
-
-  if (!child || !childPath) {
-    throw new Error(`Unable to find child at ${JSON.stringify(operation.at)}`)
-  }
-
-  if (operation.editor.isTextSpan(child)) {
-    const {_type, text, ...rest} = operation.props
-
-    Transforms.setNodes(
-      operation.editor,
-      {
-        ...child,
-        ...rest,
-      },
-      {at: childPath},
-    )
-
-    if (typeof text === 'string') {
-      if (child.text !== text) {
-        operation.editor.apply({
-          type: 'remove_text',
-          path: childPath,
-          offset: 0,
-          text: child.text,
-        })
-
-        operation.editor.apply({
-          type: 'insert_text',
-          path: childPath,
-          offset: 0,
-          text,
-        })
-      }
-    }
-
-    return
-  }
-
-  if (Element.isElement(child)) {
-    const definition = context.schema.inlineObjects.find(
-      (definition) => definition.name === child._type,
-    )
-
-    if (!definition) {
-      throw new Error(
-        `Unable to find schema definition for Inline Object type ${child._type}`,
-      )
-    }
-
-    const value =
-      'value' in child && typeof child.value === 'object' ? child.value : {}
-    const {_type, _key, ...rest} = operation.props
-
-    for (const prop in rest) {
-      if (!definition.fields.some((field) => field.name === prop)) {
-        delete rest[prop]
-      }
-    }
-
-    Transforms.setNodes(
-      operation.editor,
-      {
-        ...child,
-        _key: typeof _key === 'string' ? _key : child._key,
-        value: {
-          ...value,
-          ...rest,
-        },
-      },
-      {at: childPath},
-    )
-
-    return
-  }
-
-  throw new Error(
-    `Unable to determine the type of child at ${JSON.stringify(operation.at)}`,
-  )
-}

package/src/operations/behavior.operation.child.unset.ts

@@ -1,116 +0,0 @@
-import {applyAll} from '@portabletext/patches'
-import {isTextBlock} from '@portabletext/schema'
-import {Editor, Element, Transforms} from 'slate'
-import type {BehaviorOperationImplementation} from './behavior.operations'
-
-export const childUnsetOperationImplementation: BehaviorOperationImplementation<
-  'child.unset'
-> = ({context, operation}) => {
-  const blockKey = operation.at[0]._key
-  const blockIndex = operation.editor.blockIndexMap.get(blockKey)
-
-  if (blockIndex === undefined) {
-    throw new Error(`Unable to find block index for block key ${blockKey}`)
-  }
-
-  const block =
-    blockIndex !== undefined ? operation.editor.value.at(blockIndex) : undefined
-
-  if (!block) {
-    throw new Error(`Unable to find block at ${JSON.stringify(operation.at)}`)
-  }
-
-  if (!isTextBlock(context, block)) {
-    throw new Error(`Block ${JSON.stringify(blockKey)} is not a text block`)
-  }
-
-  const childKey = operation.at[2]._key
-
-  if (!childKey) {
-    throw new Error(
-      `Unable to find child key at ${JSON.stringify(operation.at)}`,
-    )
-  }
-
-  const childIndex = block.children.findIndex(
-    (child) => child._key === childKey,
-  )
-
-  if (childIndex === -1) {
-    throw new Error(`Unable to find child at ${JSON.stringify(operation.at)}`)
-  }
-
-  const childEntry = Editor.node(operation.editor, [blockIndex, childIndex], {
-    depth: 2,
-  })
-  const child = childEntry?.[0]
-  const childPath = childEntry?.[1]
-
-  if (!child || !childPath) {
-    throw new Error(`Unable to find child at ${JSON.stringify(operation.at)}`)
-  }
-
-  if (operation.editor.isTextSpan(child)) {
-    const newNode: Record<string, unknown> = {}
-
-    for (const prop of operation.props) {
-      if (prop === 'text') {
-        // Unsetting `text` requires special treatment
-        continue
-      }
-
-      if (prop === '_type') {
-        // It's not allowed to unset the _type of a span
-        continue
-      }
-
-      if (prop === '_key') {
-        newNode._key = context.keyGenerator()
-        continue
-      }
-
-      newNode[prop] = null
-    }
-
-    Transforms.setNodes(operation.editor, newNode, {at: childPath})
-
-    if (operation.props.includes('text')) {
-      operation.editor.apply({
-        type: 'remove_text',
-        path: childPath,
-        offset: 0,
-        text: child.text,
-      })
-    }
-
-    return
-  }
-
-  if (Element.isElement(child)) {
-    const value =
-      'value' in child && typeof child.value === 'object' ? child.value : {}
-    const patches = operation.props.map((prop) => ({
-      type: 'unset' as const,
-      path: [prop],
-    }))
-    const newValue = applyAll(value, patches)
-
-    Transforms.setNodes(
-      operation.editor,
-      {
-        ...child,
-        _key: operation.props.includes('_key')
-          ? context.keyGenerator()
-          : child._key,
-        value: newValue,
-      },
-      {at: childPath},
-    )
-
-    return
-  }
-
-  throw new Error(
-    `Unable to determine the type of child at ${JSON.stringify(operation.at)}`,
-  )
-}