@portabletext/editor 3.3.3 → 3.3.4

package/src/utils/util.get-text-block-text.ts

@@ -1,8 +0,0 @@
-import type {PortableTextTextBlock} from '@sanity/types'
-
-/**
- * @public
- */
-export function getTextBlockText(block: PortableTextTextBlock) {
-  return block.children.map((child) => child.text ?? '').join('')
-}

package/src/utils/util.is-empty-text-block.ts

@@ -1,21 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {PortableTextBlock} from '@sanity/types'
-import type {EditorContext} from '../editor/editor-snapshot'
-import {getTextBlockText} from './util.get-text-block-text'
-
-/**
- * @public
- */
-export function isEmptyTextBlock(
-  context: Pick<EditorContext, 'schema'>,
-  block: PortableTextBlock | unknown,
-) {
-  if (!isTextBlock(context, block)) {
-    return false
-  }
-
-  const onlyText = block.children.every((child) => isSpan(context, child))
-  const blockText = getTextBlockText(block)
-
-  return onlyText && blockText === ''
-}

package/src/utils/util.is-equal-selection-points.ts

@@ -1,13 +0,0 @@
-import type {EditorSelectionPoint} from '../types/editor'
-
-/**
- * @public
- */
-export function isEqualSelectionPoints(
-  a: EditorSelectionPoint,
-  b: EditorSelectionPoint,
-) {
-  return (
-    a.offset === b.offset && JSON.stringify(a.path) === JSON.stringify(b.path)
-  )
-}

package/src/utils/util.is-equal-selections.ts

@@ -1,20 +0,0 @@
-import type {EditorSelection} from '../types/editor'
-import {isEqualSelectionPoints} from './util.is-equal-selection-points'
-
-/**
- * @public
- */
-export function isEqualSelections(a: EditorSelection, b: EditorSelection) {
-  if (!a && !b) {
-    return true
-  }
-
-  if (!a || !b) {
-    return false
-  }
-
-  return (
-    isEqualSelectionPoints(a.anchor, b.anchor) &&
-    isEqualSelectionPoints(a.focus, b.focus)
-  )
-}

package/src/utils/util.is-keyed-segment.ts

@@ -1,8 +0,0 @@
-import type {KeyedSegment} from '@sanity/types'
-
-/**
- * @public
- */
-export function isKeyedSegment(segment: unknown): segment is KeyedSegment {
-  return typeof segment === 'object' && segment !== null && '_key' in segment
-}

package/src/utils/util.is-selection-collapsed.ts

@@ -1,16 +0,0 @@
-import type {EditorSelection} from '../types/editor'
-
-/**
- * @public
- */
-export function isSelectionCollapsed(selection: EditorSelection) {
-  if (!selection) {
-    return false
-  }
-
-  return (
-    JSON.stringify(selection.anchor.path) ===
-      JSON.stringify(selection.focus.path) &&
-    selection.anchor.offset === selection.focus.offset
-  )
-}

package/src/utils/util.is-selection-expanded.ts

@@ -1,13 +0,0 @@
-import type {EditorSelection} from '../types/editor'
-import {isSelectionCollapsed} from './util.is-selection-collapsed'
-
-/**
- * @public
- */
-export function isSelectionExpanded(selection: EditorSelection) {
-  if (!selection) {
-    return false
-  }
-
-  return !isSelectionCollapsed(selection)
-}

package/src/utils/util.merge-text-blocks.ts

@@ -1,40 +0,0 @@
-import {isTextBlock} from '@portabletext/schema'
-import type {PortableTextTextBlock} from '@sanity/types'
-import type {EditorContext} from '../editor/editor-snapshot'
-import {parseBlock} from './parse-blocks'
-
-/**
- * @beta
- */
-export function mergeTextBlocks({
-  context,
-  targetBlock,
-  incomingBlock,
-}: {
-  context: Pick<EditorContext, 'keyGenerator' | 'schema'>
-  targetBlock: PortableTextTextBlock
-  incomingBlock: PortableTextTextBlock
-}) {
-  const parsedIncomingBlock = parseBlock({
-    context,
-    block: incomingBlock,
-    options: {
-      normalize: false,
-      removeUnusedMarkDefs: true,
-      validateFields: false,
-    },
-  })
-
-  if (!parsedIncomingBlock || !isTextBlock(context, parsedIncomingBlock)) {
-    return targetBlock
-  }
-
-  return {
-    ...targetBlock,
-    children: [...targetBlock.children, ...parsedIncomingBlock.children],
-    markDefs: [
-      ...(targetBlock.markDefs ?? []),
-      ...(parsedIncomingBlock.markDefs ?? []),
-    ],
-  }
-}

package/src/utils/util.reverse-selection.ts

@@ -1,26 +0,0 @@
-import type {EditorSelection} from '../types/editor'
-
-/**
- * @public
- */
-export function reverseSelection<
-  TEditorSelection extends NonNullable<EditorSelection> | null,
->(selection: TEditorSelection): TEditorSelection {
-  if (!selection) {
-    return selection
-  }
-
-  if (selection.backward) {
-    return {
-      anchor: selection.focus,
-      focus: selection.anchor,
-      backward: false,
-    } as TEditorSelection
-  }
-
-  return {
-    anchor: selection.focus,
-    focus: selection.anchor,
-    backward: true,
-  } as TEditorSelection
-}

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

@@ -1,30 +0,0 @@
-import type {EditorContext} from '../editor/editor-snapshot'
-import type {BlockOffset} from '../types/block-offset'
-import type {EditorSelectionPoint} from '../types/editor'
-import {childSelectionPointToBlockOffset} from './util.child-selection-point-to-block-offset'
-import {getBlockKeyFromSelectionPoint} from './util.selection-point'
-
-/**
- * @public
- */
-export function selectionPointToBlockOffset({
-  context,
-  selectionPoint,
-}: {
-  context: Pick<EditorContext, 'schema' | 'value'>
-  selectionPoint: EditorSelectionPoint
-}): BlockOffset | undefined {
-  const blockKey = getBlockKeyFromSelectionPoint(selectionPoint)
-
-  if (selectionPoint.path.length === 1 && blockKey !== undefined) {
-    return {
-      path: [{_key: blockKey}],
-      offset: selectionPoint.offset,
-    }
-  }
-
-  return childSelectionPointToBlockOffset({
-    context,
-    selectionPoint,
-  })
-}

package/src/utils/util.selection-point.ts

@@ -1,22 +0,0 @@
-import type {EditorSelectionPoint} from '../types/editor'
-import {isKeyedSegment} from './util.is-keyed-segment'
-
-export function getBlockKeyFromSelectionPoint(point: EditorSelectionPoint) {
-  const blockPathSegment = point.path.at(0)
-
-  if (isKeyedSegment(blockPathSegment)) {
-    return blockPathSegment._key
-  }
-
-  return undefined
-}
-
-export function getChildKeyFromSelectionPoint(point: EditorSelectionPoint) {
-  const childPathSegment = point.path.at(2)
-
-  if (isKeyedSegment(childPathSegment)) {
-    return childPathSegment._key
-  }
-
-  return undefined
-}

package/src/utils/util.slice-blocks.ts

@@ -1,221 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {PortableTextBlock} from '@sanity/types'
-import type {EditorContext} from '../editor/editor-snapshot'
-import {defaultKeyGenerator} from './key-generator'
-import {parseBlock} from './parse-blocks'
-import {getSelectionEndPoint} from './util.get-selection-end-point'
-import {getSelectionStartPoint} from './util.get-selection-start-point'
-import {
-  getBlockKeyFromSelectionPoint,
-  getChildKeyFromSelectionPoint,
-} from './util.selection-point'
-
-/**
- * @public
- */
-export function sliceBlocks({
-  context,
-  blocks,
-}: {
-  context: Pick<EditorContext, 'schema' | 'selection'> & {
-    keyGenerator?: () => string
-  }
-  blocks: Array<PortableTextBlock>
-}): Array<PortableTextBlock> {
-  const slice: Array<PortableTextBlock> = []
-
-  if (!context.selection) {
-    return slice
-  }
-
-  let startBlock: PortableTextBlock | undefined
-  const middleBlocks: PortableTextBlock[] = []
-  let endBlock: PortableTextBlock | undefined
-
-  const startPoint = getSelectionStartPoint(context.selection)
-  const endPoint = getSelectionEndPoint(context.selection)
-  const startBlockKey = getBlockKeyFromSelectionPoint(startPoint)
-  const startChildKey = getChildKeyFromSelectionPoint(startPoint)
-  const endBlockKey = getBlockKeyFromSelectionPoint(endPoint)
-  const endChildKey = getChildKeyFromSelectionPoint(endPoint)
-
-  if (!startBlockKey || !endBlockKey) {
-    return slice
-  }
-
-  for (const block of blocks) {
-    if (!isTextBlock(context, block)) {
-      if (block._key === startBlockKey && block._key === endBlockKey) {
-        startBlock = block
-        break
-      }
-    }
-
-    if (block._key === startBlockKey) {
-      if (!isTextBlock(context, block)) {
-        startBlock = block
-        continue
-      }
-
-      if (startChildKey) {
-        for (const child of block.children) {
-          if (child._key === startChildKey) {
-            if (isSpan(context, child)) {
-              const text =
-                child._key === endChildKey
-                  ? child.text.slice(startPoint.offset, endPoint.offset)
-                  : child.text.slice(startPoint.offset)
-
-              startBlock = {
-                ...block,
-                children: [
-                  {
-                    ...child,
-                    text,
-                  },
-                ],
-              }
-            } else {
-              startBlock = {
-                ...block,
-                children: [child],
-              }
-            }
-
-            if (block._key === endBlockKey && startChildKey === endChildKey) {
-              break
-            }
-            continue
-          }
-
-          if (startBlock && isTextBlock(context, startBlock)) {
-            if (
-              endChildKey &&
-              child._key === endChildKey &&
-              isSpan(context, child)
-            ) {
-              startBlock.children.push({
-                ...child,
-                text: child.text.slice(0, endPoint.offset),
-              })
-            } else {
-              startBlock.children.push(child)
-            }
-
-            if (
-              block._key === endBlockKey &&
-              endChildKey &&
-              child._key === endChildKey
-            ) {
-              break
-            }
-          }
-        }
-
-        if (startBlockKey === endBlockKey) {
-          break
-        }
-
-        continue
-      }
-
-      startBlock = block
-
-      if (startBlockKey === endBlockKey) {
-        break
-      }
-    }
-
-    if (block._key === endBlockKey) {
-      if (!isTextBlock(context, block)) {
-        endBlock = block
-        break
-      }
-
-      if (endChildKey) {
-        endBlock = {
-          ...block,
-          children: [],
-        }
-
-        for (const child of block.children) {
-          if (endBlock && isTextBlock(context, endBlock)) {
-            if (child._key === endChildKey && isSpan(context, child)) {
-              endBlock.children.push({
-                ...child,
-                text: child.text.slice(0, endPoint.offset),
-              })
-
-              break
-            }
-
-            endBlock.children.push(child)
-
-            if (endChildKey && child._key === endChildKey) {
-              break
-            }
-          }
-        }
-
-        break
-      }
-
-      endBlock = block
-
-      break
-    }
-
-    if (startBlock) {
-      middleBlocks.push(
-        parseBlock({
-          context: {
-            schema: context.schema,
-            keyGenerator: context.keyGenerator ?? defaultKeyGenerator,
-          },
-          block,
-          options: {
-            normalize: false,
-            removeUnusedMarkDefs: true,
-            validateFields: false,
-          },
-        }) ?? block,
-      )
-    }
-  }
-
-  const parsedStartBlock = startBlock
-    ? parseBlock({
-        context: {
-          schema: context.schema,
-          keyGenerator: context.keyGenerator ?? defaultKeyGenerator,
-        },
-        block: startBlock,
-        options: {
-          normalize: false,
-          removeUnusedMarkDefs: true,
-          validateFields: false,
-        },
-      })
-    : undefined
-
-  const parsedEndBlock = endBlock
-    ? parseBlock({
-        context: {
-          schema: context.schema,
-          keyGenerator: context.keyGenerator ?? defaultKeyGenerator,
-        },
-        block: endBlock,
-        options: {
-          normalize: false,
-          removeUnusedMarkDefs: true,
-          validateFields: false,
-        },
-      })
-    : undefined
-
-  return [
-    ...(parsedStartBlock ? [parsedStartBlock] : []),
-    ...middleBlocks,
-    ...(parsedEndBlock ? [parsedEndBlock] : []),
-  ]
-}

package/src/utils/util.slice-text-block.test.ts

@@ -1,190 +0,0 @@
-import {compileSchema, defineSchema} from '@portabletext/schema'
-import {createTestKeyGenerator} from '@portabletext/test'
-import type {
-  PortableTextObject,
-  PortableTextSpan,
-  PortableTextTextBlock,
-} from '@sanity/types'
-import {describe, expect, test} from 'vitest'
-import {sliceTextBlock} from './util.slice-text-block'
-
-const keyGenerator = createTestKeyGenerator()
-
-const schema = compileSchema(
-  defineSchema({
-    inlineObjects: [{name: 'stock-ticker'}],
-  }),
-)
-
-function createSpan(span: Partial<PortableTextSpan>) {
-  return {
-    _type: 'span',
-    _key: span._key ?? keyGenerator(),
-    text: span.text ?? '',
-    marks: span.marks ?? [],
-  }
-}
-
-function createInlineObject(inlineObject: Partial<PortableTextObject>) {
-  return {
-    _type: 'stock-ticker',
-    _key: inlineObject._key ?? keyGenerator(),
-    ...inlineObject,
-  }
-}
-
-function createBlock(
-  block: Partial<PortableTextTextBlock>,
-): PortableTextTextBlock {
-  return {
-    _type: 'block',
-    _key: block._key ?? keyGenerator(),
-    children: block.children ?? [createSpan({})],
-    markDefs: block.markDefs ?? [],
-    style: block.style ?? 'normal',
-    ...block,
-  }
-}
-
-describe(sliceTextBlock.name, () => {
-  test('empty block', () => {
-    const span = createSpan({})
-    const block = createBlock({
-      children: [span],
-    })
-
-    expect(
-      sliceTextBlock({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: block._key}, 'children', {_key: span._key}],
-              offset: 0,
-            },
-            focus: {
-              path: [{_key: block._key}, 'children', {_key: span._key}],
-              offset: 0,
-            },
-          },
-        },
-        block,
-      }),
-    ).toEqual(block)
-  })
-
-  test('middle', () => {
-    const span = createSpan({
-      text: 'foo bar baz',
-    })
-    const block = createBlock({
-      children: [span],
-    })
-
-    expect(
-      sliceTextBlock({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: block._key}, 'children', {_key: span._key}],
-              offset: 4,
-            },
-            focus: {
-              path: [{_key: block._key}, 'children', {_key: span._key}],
-              offset: 7,
-            },
-          },
-        },
-        block,
-      }),
-    ).toEqual({
-      ...block,
-      children: [
-        {
-          ...span,
-          text: 'bar',
-        },
-      ],
-    })
-  })
-
-  describe('multiple children', () => {
-    const fooSpan = createSpan({
-      text: 'foo',
-      marks: ['strong'],
-    })
-    const barSpan = createSpan({
-      text: 'bar',
-      marks: ['em'],
-    })
-    const bazSpan = createSpan({
-      text: 'baz',
-      marks: ['underline'],
-    })
-    const stockTicker = createInlineObject({
-      symbol: 'AAPL',
-    })
-    const block = createBlock({
-      children: [fooSpan, barSpan, stockTicker, bazSpan],
-    })
-
-    test('mid-span', () => {
-      expect(
-        sliceTextBlock({
-          context: {
-            schema,
-            selection: {
-              anchor: {
-                path: [{_key: block._key}, 'children', {_key: barSpan._key}],
-                offset: 1,
-              },
-              focus: {
-                path: [{_key: block._key}, 'children', {_key: bazSpan._key}],
-                offset: 1,
-              },
-            },
-          },
-          block,
-        }),
-      ).toEqual({
-        ...block,
-        children: [
-          {
-            ...barSpan,
-            text: 'ar',
-          },
-          stockTicker,
-          {
-            ...bazSpan,
-            text: 'b',
-          },
-        ],
-      })
-    })
-
-    test('from end of span to end of block', () => {
-      expect(
-        sliceTextBlock({
-          context: {
-            schema,
-            selection: {
-              anchor: {
-                path: [{_key: block._key}, 'children', {_key: fooSpan._key}],
-                offset: 3,
-              },
-              focus: {
-                path: [{_key: block._key}, 'children', {_key: bazSpan._key}],
-                offset: 3,
-              },
-            },
-          },
-          block,
-        }),
-      ).toEqual({
-        ...block,
-        children: [{...fooSpan, text: ''}, barSpan, stockTicker, bazSpan],
-      })
-    })
-  })
-})