@portabletext/editor 3.3.3 → 3.3.4

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

@@ -1,171 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {PortableTextObject, PortableTextSpan} from '@sanity/types'
-import type {Path, Range} from 'slate'
-import type {EditorContext, EditorSnapshot} from '../editor/editor-snapshot'
-import type {EditorSelectionPoint} from '../types/editor'
-import {blockOffsetToSpanSelectionPoint} from '../utils/util.block-offset'
-import {isEqualSelectionPoints} from '../utils/util.is-equal-selection-points'
-import {
-  getBlockKeyFromSelectionPoint,
-  getChildKeyFromSelectionPoint,
-} from '../utils/util.selection-point'
-
-export function toSlateRange(
-  snapshot: {
-    context: Pick<EditorContext, 'schema' | 'value' | 'selection'>
-  } & Pick<EditorSnapshot, 'blockIndexMap'>,
-): Range | null {
-  if (!snapshot.context.selection) {
-    return null
-  }
-
-  if (
-    isEqualSelectionPoints(
-      snapshot.context.selection.anchor,
-      snapshot.context.selection.focus,
-    )
-  ) {
-    const anchorPoint = toSlateSelectionPoint(
-      snapshot,
-      snapshot.context.selection.anchor,
-      snapshot.context.selection.backward ? 'backward' : 'forward',
-    )
-
-    if (!anchorPoint) {
-      return null
-    }
-
-    return {
-      anchor: anchorPoint,
-      focus: anchorPoint,
-    }
-  }
-
-  const anchorPoint = toSlateSelectionPoint(
-    snapshot,
-    snapshot.context.selection.anchor,
-    snapshot.context.selection.backward ? 'forward' : 'backward',
-  )
-  const focusPoint = toSlateSelectionPoint(
-    snapshot,
-    snapshot.context.selection.focus,
-    snapshot.context.selection.backward ? 'backward' : 'forward',
-  )
-
-  if (!anchorPoint || !focusPoint) {
-    return null
-  }
-
-  return {
-    anchor: anchorPoint,
-    focus: focusPoint,
-  }
-}
-
-function toSlateSelectionPoint(
-  snapshot: {
-    context: Pick<EditorContext, 'schema' | 'value'>
-  } & Pick<EditorSnapshot, 'blockIndexMap'>,
-  selectionPoint: EditorSelectionPoint,
-  direction: 'forward' | 'backward',
-):
-  | {
-      path: Path
-      offset: number
-    }
-  | undefined {
-  const blockKey = getBlockKeyFromSelectionPoint(selectionPoint)
-
-  if (!blockKey) {
-    return undefined
-  }
-
-  const blockIndex = snapshot.blockIndexMap.get(blockKey)
-
-  if (blockIndex === undefined) {
-    return undefined
-  }
-
-  const block = snapshot.context.value.at(blockIndex)
-
-  if (!block) {
-    return undefined
-  }
-
-  if (!isTextBlock(snapshot.context, block)) {
-    return {
-      path: [blockIndex, 0],
-      offset: 0,
-    }
-  }
-
-  let childKey = getChildKeyFromSelectionPoint({
-    path: selectionPoint.path,
-    offset: 0,
-  })
-
-  // If the block is a text block, but there is no child key in the selection
-  // point path, then we can try to find a span selection point by the offset.
-  const spanSelectionPoint = !childKey
-    ? blockOffsetToSpanSelectionPoint({
-        context: {
-          schema: snapshot.context.schema,
-          value: [block],
-        },
-        blockOffset: {
-          path: [{_key: blockKey}],
-          offset: selectionPoint.offset,
-        },
-        direction,
-      })
-    : undefined
-
-  childKey = spanSelectionPoint
-    ? getChildKeyFromSelectionPoint(spanSelectionPoint)
-    : childKey
-
-  // If we still don't have a child key, then we have to resort to selecting
-  // the first child of the block (which by Slate convention is a span).
-  if (!childKey) {
-    return {
-      path: [blockIndex, 0],
-      offset: 0,
-    }
-  }
-
-  let offset = spanSelectionPoint?.offset ?? selectionPoint.offset
-  let childPath: Array<number> = []
-  let childIndex = -1
-  let pathChild: PortableTextSpan | PortableTextObject | 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]
-        offset = 0
-      }
-      break
-    }
-  }
-
-  // If we for some unforeseen reason didn't manage to produce a child path,
-  // then we have to resort to selecting the first child of the block (which
-  // by Slate convention is a span).
-  if (childPath.length === 0) {
-    return {
-      path: [blockIndex, 0],
-      offset: 0,
-    }
-  }
-
-  return {
-    path: [blockIndex].concat(childPath),
-    offset: isSpan(snapshot.context, pathChild)
-      ? Math.min(pathChild.text.length, offset)
-      : offset,
-  }
-}

package/src/internal-utils/validateValue.ts

@@ -1,443 +0,0 @@
-import {insert, set, setIfMissing, unset} from '@portabletext/patches'
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {
-  PortableTextBlock,
-  PortableTextSpan,
-  PortableTextTextBlock,
-} from '@sanity/types'
-import {flatten, isPlainObject, uniq} from 'lodash'
-import type {EditorSchema} from '../editor/editor-schema'
-import type {InvalidValueResolution} from '../types/editor'
-
-export interface Validation {
-  valid: boolean
-  resolution: InvalidValueResolution | null
-  value: PortableTextBlock[] | undefined
-}
-
-export function validateValue(
-  value: PortableTextBlock[] | undefined,
-  types: EditorSchema,
-  keyGenerator: () => string,
-): Validation {
-  let resolution: InvalidValueResolution | null = null
-  let valid = true
-  const validChildTypes = [
-    types.span.name,
-    ...types.inlineObjects.map((t) => t.name),
-  ]
-  const validBlockTypes = [
-    types.block.name,
-    ...types.blockObjects.map((t) => t.name),
-  ]
-
-  // Undefined is allowed
-  if (value === undefined) {
-    return {valid: true, resolution: null, value}
-  }
-  // Only lengthy arrays are allowed in the editor.
-  if (!Array.isArray(value) || value.length === 0) {
-    return {
-      valid: false,
-      resolution: {
-        patches: [unset([])],
-        description:
-          'Editor value must be an array of Portable Text blocks, or undefined.',
-        action: 'Unset the value',
-        item: value,
-
-        i18n: {
-          description:
-            'inputs.portable-text.invalid-value.not-an-array.description',
-          action: 'inputs.portable-text.invalid-value.not-an-array.action',
-        },
-      },
-      value,
-    }
-  }
-  if (
-    value.some((blk: PortableTextBlock, index: number): boolean => {
-      // Is the block an object?
-      if (!isPlainObject(blk)) {
-        resolution = {
-          patches: [unset([index])],
-          description: `Block must be an object, got ${String(blk)}`,
-          action: `Unset invalid item`,
-          item: blk,
-
-          i18n: {
-            description:
-              'inputs.portable-text.invalid-value.not-an-object.description',
-            action: 'inputs.portable-text.invalid-value.not-an-object.action',
-            values: {index},
-          },
-        }
-        return true
-      }
-      // Test that every block has a _key prop
-      if (!blk._key || typeof blk._key !== 'string') {
-        resolution = {
-          patches: [set({...blk, _key: keyGenerator()}, [index])],
-          description: `Block at index ${index} is missing required _key.`,
-          action: 'Set the block with a random _key value',
-          item: blk,
-
-          i18n: {
-            description:
-              'inputs.portable-text.invalid-value.missing-key.description',
-            action: 'inputs.portable-text.invalid-value.missing-key.action',
-            values: {index},
-          },
-        }
-        return true
-      }
-      // Test that every block has valid _type
-      if (!blk._type || !validBlockTypes.includes(blk._type)) {
-        // Special case where block type is set to default 'block', but the block type is named something else according to the schema.
-        if (blk._type === 'block') {
-          const currentBlockTypeName = types.block.name
-          resolution = {
-            patches: [
-              set({...blk, _type: currentBlockTypeName}, [{_key: blk._key}]),
-            ],
-            description: `Block with _key '${blk._key}' has invalid type name '${blk._type}'. According to the schema, the block type name is '${currentBlockTypeName}'`,
-            action: `Use type '${currentBlockTypeName}'`,
-            item: blk,
-
-            i18n: {
-              description:
-                'inputs.portable-text.invalid-value.incorrect-block-type.description',
-              action:
-                'inputs.portable-text.invalid-value.incorrect-block-type.action',
-              values: {key: blk._key, expectedTypeName: currentBlockTypeName},
-            },
-          }
-          return true
-        }
-
-        // If the block has no `_type`, but aside from that is a valid Portable Text block
-        if (
-          !blk._type &&
-          isTextBlock({schema: types}, {...blk, _type: types.block.name})
-        ) {
-          resolution = {
-            patches: [
-              set({...blk, _type: types.block.name}, [{_key: blk._key}]),
-            ],
-            description: `Block with _key '${blk._key}' is missing a type name. According to the schema, the block type name is '${types.block.name}'`,
-            action: `Use type '${types.block.name}'`,
-            item: blk,
-
-            i18n: {
-              description:
-                'inputs.portable-text.invalid-value.missing-block-type.description',
-              action:
-                'inputs.portable-text.invalid-value.missing-block-type.action',
-              values: {key: blk._key, expectedTypeName: types.block.name},
-            },
-          }
-          return true
-        }
-
-        if (!blk._type) {
-          resolution = {
-            patches: [unset([{_key: blk._key}])],
-            description: `Block with _key '${blk._key}' is missing an _type property`,
-            action: 'Remove the block',
-            item: blk,
-
-            i18n: {
-              description:
-                'inputs.portable-text.invalid-value.missing-type.description',
-              action: 'inputs.portable-text.invalid-value.missing-type.action',
-              values: {key: blk._key},
-            },
-          }
-          return true
-        }
-
-        resolution = {
-          patches: [unset([{_key: blk._key}])],
-          description: `Block with _key '${blk._key}' has invalid _type '${blk._type}'`,
-          action: 'Remove the block',
-          item: blk,
-
-          i18n: {
-            description:
-              'inputs.portable-text.invalid-value.disallowed-type.description',
-            action: 'inputs.portable-text.invalid-value.disallowed-type.action',
-            values: {key: blk._key, typeName: blk._type},
-          },
-        }
-        return true
-      }
-
-      // Test regular text blocks
-      if (blk._type === types.block.name) {
-        const textBlock = blk as PortableTextTextBlock
-        // Test that it has a valid children property (array)
-        if (textBlock.children && !Array.isArray(textBlock.children)) {
-          resolution = {
-            patches: [set({children: []}, [{_key: textBlock._key}])],
-            description: `Text block with _key '${textBlock._key}' has a invalid required property 'children'.`,
-            action: 'Reset the children property',
-            item: textBlock,
-
-            i18n: {
-              description:
-                'inputs.portable-text.invalid-value.missing-or-invalid-children.description',
-              action:
-                'inputs.portable-text.invalid-value.missing-or-invalid-children.action',
-              values: {key: textBlock._key},
-            },
-          }
-          return true
-        }
-        // Test that children is set and lengthy
-        if (
-          textBlock.children === undefined ||
-          (Array.isArray(textBlock.children) && textBlock.children.length === 0)
-        ) {
-          const newSpan = {
-            _type: types.span.name,
-            _key: keyGenerator(),
-            text: '',
-            marks: [],
-          }
-          resolution = {
-            autoResolve: true,
-            patches: [
-              setIfMissing([], [{_key: blk._key}, 'children']),
-              insert([newSpan], 'after', [{_key: blk._key}, 'children', 0]),
-            ],
-            description: `Children for text block with _key '${blk._key}' is empty.`,
-            action: 'Insert an empty text',
-            item: blk,
-
-            i18n: {
-              description:
-                'inputs.portable-text.invalid-value.empty-children.description',
-              action:
-                'inputs.portable-text.invalid-value.empty-children.action',
-              values: {key: blk._key},
-            },
-          }
-          return true
-        }
-
-        const allUsedMarks = uniq(
-          flatten(
-            textBlock.children
-              .filter((child) => isSpan({schema: types}, child))
-              .map((cld) => cld.marks || []),
-          ),
-        )
-
-        // Test that all markDefs are in use (remove orphaned markDefs)
-        if (Array.isArray(blk.markDefs) && blk.markDefs.length > 0) {
-          const unusedMarkDefs: string[] = uniq(
-            blk.markDefs
-              .map((def) => def._key)
-              .filter((key) => !allUsedMarks.includes(key)),
-          )
-          if (unusedMarkDefs.length > 0) {
-            resolution = {
-              autoResolve: true,
-              patches: unusedMarkDefs.map((markDefKey) =>
-                unset([{_key: blk._key}, 'markDefs', {_key: markDefKey}]),
-              ),
-              description: `Block contains orphaned data (unused mark definitions): ${unusedMarkDefs.join(
-                ', ',
-              )}.`,
-              action: 'Remove unused mark definition item',
-              item: blk,
-              i18n: {
-                description:
-                  'inputs.portable-text.invalid-value.orphaned-mark-defs.description',
-                action:
-                  'inputs.portable-text.invalid-value.orphaned-mark-defs.action',
-                values: {
-                  key: blk._key,
-                  unusedMarkDefs: unusedMarkDefs.map((m) => m.toString()),
-                },
-              },
-            }
-            return true
-          }
-        }
-
-        // Test that every annotation mark used has a definition
-        const annotationMarks = allUsedMarks.filter(
-          (mark) => !types.decorators.map((dec) => dec.name).includes(mark),
-        )
-        const orphanedMarks = annotationMarks.filter(
-          (mark) =>
-            textBlock.markDefs === undefined ||
-            !textBlock.markDefs.find((def) => def._key === mark),
-        )
-        if (orphanedMarks.length > 0) {
-          const spanChildren = textBlock.children.filter(
-            (cld) =>
-              cld._type === types.span.name &&
-              Array.isArray(cld.marks) &&
-              cld.marks.some((mark) => orphanedMarks.includes(mark)),
-          ) as PortableTextSpan[]
-          if (spanChildren) {
-            const orphaned = orphanedMarks.join(', ')
-            resolution = {
-              autoResolve: true,
-              patches: spanChildren.map((child) => {
-                return set(
-                  (child.marks || []).filter(
-                    (cMrk) => !orphanedMarks.includes(cMrk),
-                  ),
-                  [{_key: blk._key}, 'children', {_key: child._key}, 'marks'],
-                )
-              }),
-              description: `Block with _key '${blk._key}' contains marks (${orphaned}) not supported by the current content model.`,
-              action: 'Remove invalid marks',
-              item: blk,
-
-              i18n: {
-                description:
-                  'inputs.portable-text.invalid-value.orphaned-marks.description',
-                action:
-                  'inputs.portable-text.invalid-value.orphaned-marks.action',
-                values: {
-                  key: blk._key,
-                  orphanedMarks: orphanedMarks.map((m) => m.toString()),
-                },
-              },
-            }
-            return true
-          }
-        }
-
-        // Test every child
-        if (
-          textBlock.children.some((child, cIndex: number) => {
-            if (!isPlainObject(child)) {
-              resolution = {
-                patches: [unset([{_key: blk._key}, 'children', cIndex])],
-                description: `Child at index '${cIndex}' in block with key '${blk._key}' is not an object.`,
-                action: 'Remove the item',
-                item: blk,
-
-                i18n: {
-                  description:
-                    'inputs.portable-text.invalid-value.non-object-child.description',
-                  action:
-                    'inputs.portable-text.invalid-value.non-object-child.action',
-                  values: {key: blk._key, index: cIndex},
-                },
-              }
-              return true
-            }
-
-            if (!child._key || typeof child._key !== 'string') {
-              const newChild = {...child, _key: keyGenerator()}
-              resolution = {
-                autoResolve: true,
-                patches: [
-                  set(newChild, [{_key: blk._key}, 'children', cIndex]),
-                ],
-                description: `Child at index ${cIndex} is missing required _key in block with _key ${blk._key}.`,
-                action: 'Set a new random _key on the object',
-                item: blk,
-
-                i18n: {
-                  description:
-                    'inputs.portable-text.invalid-value.missing-child-key.description',
-                  action:
-                    'inputs.portable-text.invalid-value.missing-child-key.action',
-                  values: {key: blk._key, index: cIndex},
-                },
-              }
-              return true
-            }
-
-            // Verify that children have valid types
-            if (!child._type) {
-              resolution = {
-                patches: [
-                  unset([{_key: blk._key}, 'children', {_key: child._key}]),
-                ],
-                description: `Child with _key '${child._key}' in block with key '${blk._key}' is missing '_type' property.`,
-                action: 'Remove the object',
-                item: blk,
-
-                i18n: {
-                  description:
-                    'inputs.portable-text.invalid-value.missing-child-type.description',
-                  action:
-                    'inputs.portable-text.invalid-value.missing-child-type.action',
-                  values: {key: blk._key, childKey: child._key},
-                },
-              }
-              return true
-            }
-
-            if (!validChildTypes.includes(child._type)) {
-              resolution = {
-                patches: [
-                  unset([{_key: blk._key}, 'children', {_key: child._key}]),
-                ],
-                description: `Child with _key '${child._key}' in block with key '${blk._key}' has invalid '_type' property (${child._type}).`,
-                action: 'Remove the object',
-                item: blk,
-
-                i18n: {
-                  description:
-                    'inputs.portable-text.invalid-value.disallowed-child-type.description',
-                  action:
-                    'inputs.portable-text.invalid-value.disallowed-child-type.action',
-                  values: {
-                    key: blk._key,
-                    childKey: child._key,
-                    childType: child._type,
-                  },
-                },
-              }
-              return true
-            }
-
-            // Verify that spans have .text property that is a string
-            if (
-              child._type === types.span.name &&
-              typeof child.text !== 'string'
-            ) {
-              resolution = {
-                patches: [
-                  set({...child, text: ''}, [
-                    {_key: blk._key},
-                    'children',
-                    {_key: child._key},
-                  ]),
-                ],
-                description: `Child with _key '${child._key}' in block with key '${blk._key}' has missing or invalid text property!`,
-                action: `Write an empty text property to the object`,
-                item: blk,
-
-                i18n: {
-                  description:
-                    'inputs.portable-text.invalid-value.invalid-span-text.description',
-                  action:
-                    'inputs.portable-text.invalid-value.invalid-span-text.action',
-                  values: {key: blk._key, childKey: child._key},
-                },
-              }
-              return true
-            }
-            return false
-          })
-        ) {
-          valid = false
-        }
-      }
-      return false
-    })
-  ) {
-    valid = false
-  }
-  return {valid, resolution, value}
-}

package/src/internal-utils/value-annotations.ts

@@ -1,33 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {PortableTextBlock} from '@sanity/types'
-import type {EditorSchema} from '../editor/editor-schema'
-
-export function getValueAnnotations(
-  schema: EditorSchema,
-  value: Array<PortableTextBlock> | undefined,
-): Array<string> {
-  if (!value) {
-    return []
-  }
-
-  const annotations: Array<string> = []
-
-  for (const block of value) {
-    if (isTextBlock({schema}, block)) {
-      for (const child of block.children) {
-        if (isSpan({schema}, child) && child.marks) {
-          for (const mark of child.marks) {
-            if (
-              block.markDefs?.some((markDef) => markDef._key === mark) &&
-              !annotations.includes(mark)
-            ) {
-              annotations.push(mark)
-            }
-          }
-        }
-      }
-    }
-  }
-
-  return annotations
-}