@portabletext/editor 1.33.5 → 1.34.0

package/src/internal-utils/parse-blocks.ts

@@ -1,8 +1,10 @@
-import {
-  isPortableTextSpan,
-  isPortableTextTextBlock,
-  type PortableTextBlock,
+import type {
+  PortableTextBlock,
+  PortableTextObject,
+  PortableTextSpan,
+  PortableTextTextBlock,
 } from '@sanity/types'
+import type {EditorSchema} from '../editor/define-schema'
 import type {EditorContext} from '../editor/editor-snapshot'
 import {isTypedObject} from './asserters'
 
@@ -17,54 +19,92 @@ export function parseBlock({
     refreshKeys: boolean
   }
 }): PortableTextBlock | undefined {
-  if (!isTypedObject(block)) {
+  return (
+    parseTextBlock({block, context, options}) ??
+    parseBlockObject({blockObject: block, context, options})
+  )
+}
+
+function parseBlockObject({
+  blockObject,
+  context,
+  options,
+}: {
+  blockObject: unknown
+  context: Pick<EditorContext, 'keyGenerator' | 'schema'>
+  options: {refreshKeys: boolean}
+}): PortableTextObject | undefined {
+  if (!isTypedObject(blockObject)) {
     return undefined
   }
 
   if (
-    block._type !== context.schema.block.name &&
-    !context.schema.blockObjects.some(
-      (blockObject) => blockObject.name === block._type,
-    )
+    blockObject._type === context.schema.block.name ||
+    blockObject._type === 'block' ||
+    !context.schema.blockObjects.some(({name}) => name === blockObject._type)
   ) {
     return undefined
   }
 
-  if (block._type !== context.schema.block.name) {
-    const _key = options.refreshKeys
+  return {
+    ...blockObject,
+    _key: options.refreshKeys
       ? context.keyGenerator()
-      : typeof block._key === 'string'
-        ? block._key
-        : context.keyGenerator()
-    return {
-      ...block,
-      _key,
-    }
+      : typeof blockObject._key === 'string'
+        ? blockObject._key
+        : context.keyGenerator(),
   }
+}
 
-  if (!isPortableTextTextBlock(block)) {
-    return {
-      _type: context.schema.block.name,
-      _key: options.refreshKeys
-        ? context.keyGenerator()
-        : typeof block._key === 'string'
-          ? block._key
-          : context.keyGenerator(),
-      children: [
-        {
-          _key: context.keyGenerator(),
-          _type: context.schema.span.name,
-          text: '',
-          marks: [],
-        },
-      ],
-      markDefs: [],
-      style: context.schema.styles[0].value,
-    }
+export function isTextBlock(
+  schema: EditorSchema,
+  block: unknown,
+): block is PortableTextTextBlock {
+  return (
+    parseTextBlock({
+      block,
+      context: {schema, keyGenerator: () => ''},
+      options: {refreshKeys: false},
+    }) !== undefined
+  )
+}
+
+function parseTextBlock({
+  block,
+  context,
+  options,
+}: {
+  block: unknown
+  context: Pick<EditorContext, 'keyGenerator' | 'schema'>
+  options: {refreshKeys: boolean}
+}): PortableTextTextBlock | undefined {
+  if (!isTypedObject(block)) {
+    return undefined
+  }
+
+  if (block._type !== context.schema.block.name) {
+    return undefined
   }
 
+  const _key = options.refreshKeys
+    ? context.keyGenerator()
+    : typeof block._key === 'string'
+      ? block._key
+      : context.keyGenerator()
+
+  const unparsedMarkDefs: Array<unknown> = Array.isArray(block.markDefs)
+    ? block.markDefs
+    : []
   const markDefKeyMap = new Map<string, string>()
-  const markDefs = (block.markDefs ?? []).flatMap((markDef) => {
+  const markDefs = unparsedMarkDefs.flatMap((markDef) => {
+    if (!isTypedObject(markDef)) {
+      return []
+    }
+
+    if (typeof markDef._key !== 'string') {
+      return []
+    }
+
     if (
       context.schema.annotations.some(
         (annotation) => annotation.name === markDef._type,
@@ -84,55 +124,22 @@ export function parseBlock({
     return []
   })
 
-  const children = block.children.flatMap((child) => {
-    if (!isTypedObject(child)) {
-      return []
-    }
-
-    if (
-      child._type !== context.schema.span.name &&
-      !context.schema.inlineObjects.some(
-        (inlineObject) => inlineObject.name === child._type,
-      )
-    ) {
-      return []
-    }
-
-    if (!isPortableTextSpan(child)) {
-      return [
-        {
-          ...child,
-          _key: options.refreshKeys ? context.keyGenerator() : child._key,
-        },
-      ]
-    }
+  const unparsedChildren: Array<unknown> = Array.isArray(block.children)
+    ? block.children
+    : []
 
-    const marks = (child.marks ?? []).flatMap((mark) => {
-      if (markDefKeyMap.has(mark)) {
-        return [markDefKeyMap.get(mark)]
-      }
-
-      if (
-        context.schema.decorators.some((decorator) => decorator.value === mark)
-      ) {
-        return [mark]
-      }
-
-      return []
-    })
-
-    return [
-      {
-        ...child,
-        _key: options.refreshKeys ? context.keyGenerator() : child._key,
-        marks,
-      },
-    ]
-  })
+  const children = unparsedChildren
+    .map(
+      (child) =>
+        parseSpan({span: child, context, markDefKeyMap, options}) ??
+        parseInlineObject({inlineObject: child, context, options}),
+    )
+    .filter((child) => child !== undefined)
 
-  const parsedBlock = {
+  const parsedBlock: PortableTextTextBlock = {
+    // Spread the entire block to allow custom properties on it
     ...block,
-    _key: options.refreshKeys ? context.keyGenerator() : block._key,
+    _key,
     children:
       children.length > 0
         ? children
@@ -147,8 +154,14 @@ export function parseBlock({
     markDefs,
   }
 
-  if (!context.schema.styles.find((style) => style.value === block.style)) {
-    const defaultStyle = context.schema.styles[0].value
+  /**
+   * Reset text block .style if it's somehow set to an invalid type
+   */
+  if (
+    typeof parsedBlock.style !== 'string' ||
+    !context.schema.styles.find((style) => style.value === block.style)
+  ) {
+    const defaultStyle = context.schema.styles.at(0)?.value
 
     if (defaultStyle !== undefined) {
       parsedBlock.style = defaultStyle
@@ -157,10 +170,112 @@ export function parseBlock({
     }
   }
 
-  if (!context.schema.lists.find((list) => list.value === block.listItem)) {
+  /**
+   * Reset text block .listItem if it's somehow set to an invalid type
+   */
+  if (
+    typeof parsedBlock.listItem !== 'string' ||
+    !context.schema.lists.find((list) => list.value === block.listItem)
+  ) {
     delete parsedBlock.listItem
+  }
+
+  /**
+   * Reset text block .level if it's somehow set to an invalid type
+   */
+  if (typeof parsedBlock.level !== 'number') {
     delete parsedBlock.level
   }
 
   return parsedBlock
 }
+
+export function parseSpan({
+  span,
+  context,
+  markDefKeyMap,
+  options,
+}: {
+  span: unknown
+  context: Pick<EditorContext, 'keyGenerator' | 'schema'>
+  markDefKeyMap: Map<string, string>
+  options: {refreshKeys: boolean}
+}): PortableTextSpan | undefined {
+  if (!isTypedObject(span)) {
+    return undefined
+  }
+
+  // In reality, the span schema name is always 'span', but we only the check here anyway
+  if (span._type !== context.schema.span.name || span._type !== 'span') {
+    return undefined
+  }
+
+  const unparsedMarks: Array<unknown> = Array.isArray(span.marks)
+    ? span.marks
+    : []
+  const marks = unparsedMarks.flatMap((mark) => {
+    if (typeof mark !== 'string') {
+      return []
+    }
+
+    const markDefKey = markDefKeyMap.get(mark)
+
+    if (markDefKey !== undefined) {
+      return [markDefKey]
+    }
+
+    if (
+      context.schema.decorators.some((decorator) => decorator.value === mark)
+    ) {
+      return [mark]
+    }
+
+    return []
+  })
+
+  return {
+    // Spread the entire span to allow custom properties on it
+    ...span,
+    _type: 'span',
+    _key: options.refreshKeys
+      ? context.keyGenerator()
+      : typeof span._key === 'string'
+        ? span._key
+        : context.keyGenerator(),
+    text: typeof span.text === 'string' ? span.text : '',
+    marks,
+  }
+}
+
+function parseInlineObject({
+  inlineObject,
+  context,
+  options,
+}: {
+  inlineObject: unknown
+  context: Pick<EditorContext, 'keyGenerator' | 'schema'>
+  options: {refreshKeys: boolean}
+}): PortableTextObject | undefined {
+  if (!isTypedObject(inlineObject)) {
+    return undefined
+  }
+
+  if (
+    inlineObject._type === context.schema.span.name ||
+    inlineObject._type === 'span' ||
+    // Respect the schema definition and don't parse inline objects that are not defined
+    !context.schema.inlineObjects.some(({name}) => name === inlineObject._type)
+  ) {
+    return undefined
+  }
+
+  return {
+    // Spread the entire inline object to allow custom properties on it
+    ...inlineObject,
+    _key: options.refreshKeys
+      ? context.keyGenerator()
+      : typeof inlineObject._key === 'string'
+        ? inlineObject._key
+        : context.keyGenerator(),
+  }
+}

package/src/utils/index.ts

@@ -5,6 +5,7 @@ export {
   spanSelectionPointToBlockOffset,
 } from './util.block-offset'
 export {blockOffsetsToSelection} from './util.block-offsets-to-selection'
+export {childSelectionPointToBlockOffset} from './util.child-selection-point-to-block-offset'
 export {getBlockEndPoint} from './util.get-block-end-point'
 export {getBlockStartPoint} from './util.get-block-start-point'
 export {getTextBlockText} from './util.get-text-block-text'

package/src/utils/util.child-selection-point-to-block-offset.ts

@@ -0,0 +1,55 @@
+import {
+  isPortableTextSpan,
+  isPortableTextTextBlock,
+  type PortableTextBlock,
+} from '@sanity/types'
+import type {BlockOffset} from '../behaviors/behavior.types'
+import type {EditorSelectionPoint} from '../types/editor'
+import {isKeyedSegment} from './util.is-keyed-segment'
+
+/**
+ * @public
+ */
+export function childSelectionPointToBlockOffset({
+  value,
+  selectionPoint,
+}: {
+  value: Array<PortableTextBlock>
+  selectionPoint: EditorSelectionPoint
+}): BlockOffset | undefined {
+  let offset = 0
+
+  const blockKey = isKeyedSegment(selectionPoint.path[0])
+    ? selectionPoint.path[0]._key
+    : undefined
+  const childKey = isKeyedSegment(selectionPoint.path[2])
+    ? selectionPoint.path[2]._key
+    : undefined
+
+  if (!blockKey || !childKey) {
+    return undefined
+  }
+
+  for (const block of value) {
+    if (block._key !== blockKey) {
+      continue
+    }
+
+    if (!isPortableTextTextBlock(block)) {
+      continue
+    }
+
+    for (const child of block.children) {
+      if (child._key === childKey) {
+        return {
+          path: [{_key: block._key}],
+          offset: offset + selectionPoint.offset,
+        }
+      }
+
+      if (isPortableTextSpan(child)) {
+        offset += child.text.length
+      }
+    }
+  }
+}

package/src/behavior-actions/behavior.action.text-block.set.ts

@@ -1,25 +0,0 @@
-import {Transforms} from 'slate'
-import {toSlateRange} from '../internal-utils/ranges'
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const textBlockSetActionImplementation: BehaviorActionImplementation<
-  'text block.set'
-> = ({action}) => {
-  const at = toSlateRange(
-    {
-      anchor: {path: action.at, offset: 0},
-      focus: {path: action.at, offset: 0},
-    },
-    action.editor,
-  )!
-
-  Transforms.setNodes(
-    action.editor,
-    {
-      ...(action.style ? {style: action.style} : {}),
-      ...(action.listItem ? {listItem: action.listItem} : {}),
-      ...(action.level ? {level: action.level} : {}),
-    },
-    {at},
-  )
-}

package/src/behavior-actions/behavior.action.text-block.unset.ts

@@ -1,17 +0,0 @@
-import {Transforms} from 'slate'
-import {toSlateRange} from '../internal-utils/ranges'
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const textBlockUnsetActionImplementation: BehaviorActionImplementation<
-  'text block.unset'
-> = ({action}) => {
-  const at = toSlateRange(
-    {
-      anchor: {path: action.at, offset: 0},
-      focus: {path: action.at, offset: 0},
-    },
-    action.editor,
-  )!
-
-  Transforms.unsetNodes(action.editor, action.props, {at})
-}