@portabletext/editor 3.3.3 → 3.3.4

package/src/internal-utils/portable-text-node.ts

@@ -1,209 +0,0 @@
-import type {EditorSchema} from '../editor/editor-schema'
-import {isTypedObject} from '../utils/asserters'
-
-type Path = Array<number>
-
-export type PortableTextNode<TEditorSchema extends EditorSchema> =
-  | EditorNode<TEditorSchema>
-  | TextBlockNode<TEditorSchema>
-  | SpanNode<TEditorSchema>
-  | PartialSpanNode
-  | ObjectNode
-
-//////////
-
-export type EditorNode<TEditorSchema extends EditorSchema> = {
-  children: Array<TextBlockNode<TEditorSchema> | ObjectNode>
-}
-
-export function isEditorNode<TEditorSchema extends EditorSchema>(
-  node: unknown,
-): node is EditorNode<TEditorSchema> {
-  if (typeof node === 'object' && node !== null) {
-    return (
-      !('_type' in node) && 'children' in node && Array.isArray(node.children)
-    )
-  }
-
-  return false
-}
-
-//////////
-
-export type TextBlockNode<TEditorSchema extends EditorSchema> = {
-  _key?: string
-  _type: TEditorSchema['block']['name']
-  children: Array<SpanNode<TEditorSchema> | ObjectNode>
-  [other: string]: unknown
-}
-
-export function isTextBlockNode<TEditorSchema extends EditorSchema>(
-  context: {schema: TEditorSchema},
-  node: unknown,
-): node is TextBlockNode<TEditorSchema> {
-  return isTypedObject(node) && node._type === context.schema.block.name
-}
-
-//////////
-
-export type SpanNode<TEditorSchema extends EditorSchema> = {
-  _key?: string
-  _type?: TEditorSchema['span']['name']
-  text: string
-  [other: string]: unknown
-}
-
-export function isSpanNode<TEditorSchema extends EditorSchema>(
-  context: {schema: TEditorSchema},
-  node: unknown,
-): node is SpanNode<TEditorSchema> {
-  if (typeof node !== 'object' || node === null) {
-    return false
-  }
-
-  if ('children' in node) {
-    return false
-  }
-
-  if ('_type' in node) {
-    return node._type === context.schema.span.name
-  }
-
-  return 'text' in node
-}
-
-//////////
-
-export type PartialSpanNode = {
-  text: string
-  [other: string]: unknown
-}
-
-export function isPartialSpanNode(node: unknown): node is PartialSpanNode {
-  return (
-    typeof node === 'object' &&
-    node !== null &&
-    'text' in node &&
-    typeof node.text === 'string'
-  )
-}
-
-//////////
-
-export type ObjectNode = {
-  _type: string
-  _key: string
-  [other: string]: unknown
-}
-
-export function isObjectNode(
-  context: {schema: EditorSchema},
-  node: unknown,
-): node is ObjectNode {
-  return (
-    !isEditorNode(node) &&
-    !isTextBlockNode(context, node) &&
-    !isSpanNode(context, node) &&
-    !isPartialSpanNode(node)
-  )
-}
-
-/**
- *
- */
-export function getBlock<TEditorSchema extends EditorSchema>(
-  root: EditorNode<TEditorSchema>,
-  path: Path,
-): TextBlockNode<TEditorSchema> | ObjectNode | undefined {
-  const index = path.at(0)
-
-  if (index === undefined || path.length !== 1) {
-    return undefined
-  }
-
-  return root.children.at(index)
-}
-
-/**
- * A "node" can either be
- * 1. The root (path length is 0)
- * 2. A block (path length is 1)
- * 3. A span (path length is 2)
- * 4. Or an inline object (path length is 2)
- */
-export function getNode<TEditorSchema extends EditorSchema>(
-  context: {schema: TEditorSchema},
-  root: EditorNode<TEditorSchema>,
-  path: Path,
-): PortableTextNode<TEditorSchema> | undefined {
-  if (path.length === 0) {
-    return root
-  }
-
-  if (path.length === 1) {
-    return getBlock(root, path)
-  }
-
-  if (path.length === 2) {
-    const block = getBlock(root, path.slice(0, 1))
-
-    if (!block || !isTextBlockNode(context, block)) {
-      return undefined
-    }
-
-    const child = block.children.at(path[1])
-
-    if (!child) {
-      return undefined
-    }
-
-    return child
-  }
-}
-
-export function getSpan<TEditorSchema extends EditorSchema>(
-  context: {schema: TEditorSchema},
-  root: EditorNode<TEditorSchema>,
-  path: Path,
-) {
-  const node = getNode(context, root, path)
-
-  if (node && isSpanNode(context, node)) {
-    return node
-  }
-
-  return undefined
-}
-
-/**
- * A parent can either be the root or a text block
- */
-export function getParent<TEditorSchema extends EditorSchema>(
-  context: {schema: TEditorSchema},
-  root: EditorNode<TEditorSchema>,
-  path: Path,
-) {
-  if (path.length === 0) {
-    return undefined
-  }
-
-  const parentPath = path.slice(0, -1)
-
-  if (parentPath.length === 0) {
-    return root
-  }
-
-  const blockIndex = parentPath.at(0)
-
-  if (blockIndex === undefined || parentPath.length !== 1) {
-    return undefined
-  }
-
-  const block = root.children.at(blockIndex)
-
-  if (block && isTextBlockNode(context, block)) {
-    return block
-  }
-
-  return undefined
-}

package/src/internal-utils/schema.ts

@@ -1,8 +0,0 @@
-import {Schema} from '@sanity/schema'
-
-export function compileType(rawType: any) {
-  return Schema.compile({
-    name: 'blockTypeSchema',
-    types: [rawType],
-  }).get(rawType.name)
-}

package/src/internal-utils/selection-block-keys.ts

@@ -1,20 +0,0 @@
-import type {EditorSelection} from '../types/editor'
-import {getBlockKeyFromSelectionPoint} from '../utils/util.selection-point'
-
-export function getSelectionBlockKeys(selection: EditorSelection) {
-  if (!selection) {
-    return undefined
-  }
-
-  const anchorBlockKey = getBlockKeyFromSelectionPoint(selection.anchor)
-  const focusBlockKey = getBlockKeyFromSelectionPoint(selection.focus)
-
-  if (anchorBlockKey === undefined || focusBlockKey === undefined) {
-    return undefined
-  }
-
-  return {
-    anchor: anchorBlockKey,
-    focus: focusBlockKey,
-  }
-}

package/src/internal-utils/selection-focus-text.ts

@@ -1,40 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {EditorContext} from '../editor/editor-snapshot'
-import {
-  getBlockKeyFromSelectionPoint,
-  getChildKeyFromSelectionPoint,
-} from '../utils/util.selection-point'
-
-export function getSelectionFocusText(
-  context: Pick<EditorContext, 'schema' | 'value' | 'selection'>,
-) {
-  if (!context.selection) {
-    return undefined
-  }
-
-  const focusBlockKey = getBlockKeyFromSelectionPoint(context.selection.focus)
-  const focusChildKey = getChildKeyFromSelectionPoint(context.selection.focus)
-
-  if (focusBlockKey === undefined || focusChildKey === undefined) {
-    return undefined
-  }
-
-  let text: string | undefined
-
-  for (const block of context.value) {
-    if (isTextBlock(context, block)) {
-      if (block._key === focusBlockKey) {
-        for (const child of block.children) {
-          if (isSpan(context, child)) {
-            if (child._key === focusChildKey) {
-              text = child.text
-              break
-            }
-          }
-        }
-      }
-    }
-  }
-
-  return text
-}

package/src/internal-utils/selection-text.test.ts

@@ -1,32 +0,0 @@
-import {compileSchema, defineSchema} from '@portabletext/schema'
-import {createTestKeyGenerator} from '@portabletext/test'
-import {expect, test} from 'vitest'
-import {getSelectionText} from './selection-text'
-
-test(getSelectionText.name, () => {
-  const keyGenerator = createTestKeyGenerator()
-  const schema = compileSchema(defineSchema({}))
-  const splitBlock = {
-    _type: 'block',
-    _key: 'A-4',
-    style: 'normal',
-    markDefs: [{_type: 'link', _key: 'A-5', href: 'https://example.com'}],
-    children: [
-      {_type: 'span', _key: 'A-3', text: 'foo ', marks: []},
-      {_type: 'span', _key: 'A-7', marks: ['A-5'], text: 'bar'},
-      {_type: 'span', _key: 'A-6', marks: [], text: ' baz'},
-    ],
-  }
-
-  expect(
-    getSelectionText({
-      keyGenerator,
-      schema,
-      value: [splitBlock],
-      selection: {
-        anchor: {path: [{_key: 'A-4'}, 'children', {_key: 'A-7'}], offset: 0},
-        focus: {path: [{_key: 'A-4'}, 'children', {_key: 'A-7'}], offset: 3},
-      },
-    }),
-  ).toEqual(['bar'])
-})

package/src/internal-utils/selection-text.ts

@@ -1,21 +0,0 @@
-import {getTersePt} from '@portabletext/test'
-import type {EditorContext} from '../editor/editor-snapshot'
-import {sliceBlocks} from '../utils/util.slice-blocks'
-
-export function getSelectionText(
-  context: Pick<
-    EditorContext,
-    'keyGenerator' | 'schema' | 'value' | 'selection'
-  >,
-) {
-  if (!context.selection) {
-    return []
-  }
-
-  const slice = sliceBlocks({
-    context,
-    blocks: context.value,
-  })
-
-  return getTersePt({schema: context.schema, value: slice})
-}

package/src/internal-utils/selection.ts

@@ -1,77 +0,0 @@
-import type {Path, PortableTextBlock} from '@sanity/types'
-import {isEqual} from 'lodash'
-import type {EditorSelection, EditorSelectionPoint} from '../types/editor'
-
-export function normalizePoint(
-  point: EditorSelectionPoint,
-  value: PortableTextBlock[],
-): EditorSelectionPoint | null {
-  if (!point || !value) {
-    return null
-  }
-  const newPath: Path = []
-  let newOffset: number = point.offset || 0
-  const blockKey =
-    typeof point.path[0] === 'object' &&
-    '_key' in point.path[0] &&
-    point.path[0]._key
-  const childKey =
-    typeof point.path[2] === 'object' &&
-    '_key' in point.path[2] &&
-    point.path[2]._key
-  const block: PortableTextBlock | undefined = value.find(
-    (blk) => blk._key === blockKey,
-  )
-  if (block) {
-    newPath.push({_key: block._key})
-  } else {
-    return null
-  }
-  if (block && point.path[1] === 'children') {
-    if (
-      !block.children ||
-      (Array.isArray(block.children) && block.children.length === 0)
-    ) {
-      return null
-    }
-    const child =
-      Array.isArray(block.children) &&
-      block.children.find((cld) => cld._key === childKey)
-    if (child) {
-      newPath.push('children')
-      newPath.push({_key: child._key})
-      newOffset =
-        child.text && child.text.length >= point.offset
-          ? point.offset
-          : (child.text && child.text.length) || 0
-    } else {
-      return null
-    }
-  }
-  return {path: newPath, offset: newOffset}
-}
-
-export function normalizeSelection(
-  selection: EditorSelection,
-  value: PortableTextBlock[] | undefined,
-): EditorSelection | null {
-  if (!selection || !value || value.length === 0) {
-    return null
-  }
-  let newAnchor: EditorSelectionPoint | null = null
-  let newFocus: EditorSelectionPoint | null = null
-  const {anchor, focus} = selection
-  if (
-    anchor &&
-    value.find((blk) => isEqual({_key: blk._key}, anchor.path[0]))
-  ) {
-    newAnchor = normalizePoint(anchor, value)
-  }
-  if (focus && value.find((blk) => isEqual({_key: blk._key}, focus.path[0]))) {
-    newFocus = normalizePoint(focus, value)
-  }
-  if (newAnchor && newFocus) {
-    return {anchor: newAnchor, focus: newFocus, backward: selection.backward}
-  }
-  return null
-}

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

@@ -1,55 +0,0 @@
-import type {PortableTextSpan} from '@sanity/types'
-import {Node, Path} from 'slate'
-import type {PortableTextSlateEditor} from '../types/slate-editor'
-
-export function getPreviousSpan({
-  editor,
-  blockPath,
-  spanPath,
-}: {
-  editor: PortableTextSlateEditor
-  blockPath: Path
-  spanPath: Path
-}): PortableTextSpan | undefined {
-  let previousSpan: PortableTextSpan | undefined
-
-  for (const [child, childPath] of Node.children(editor, blockPath, {
-    reverse: true,
-  })) {
-    if (!editor.isTextSpan(child)) {
-      continue
-    }
-
-    if (Path.isBefore(childPath, spanPath)) {
-      previousSpan = child
-      break
-    }
-  }
-
-  return previousSpan
-}
-
-export function getNextSpan({
-  editor,
-  blockPath,
-  spanPath,
-}: {
-  editor: PortableTextSlateEditor
-  blockPath: Path
-  spanPath: Path
-}): PortableTextSpan | undefined {
-  let nextSpan: PortableTextSpan | undefined
-
-  for (const [child, childPath] of Node.children(editor, blockPath)) {
-    if (!editor.isTextSpan(child)) {
-      continue
-    }
-
-    if (Path.isAfter(childPath, spanPath)) {
-      nextSpan = child
-      break
-    }
-  }
-
-  return nextSpan
-}

package/src/internal-utils/slate-utils.test.tsx

@@ -1,121 +0,0 @@
-import {defineSchema} from '@portabletext/schema'
-import {createTestKeyGenerator} from '@portabletext/test'
-import React from 'react'
-import {describe, expect, test} from 'vitest'
-import {InternalSlateEditorRefPlugin} from '../plugins/plugin.internal.slate-editor-ref'
-import {createTestEditor} from '../test/vitest'
-import type {PortableTextSlateEditor} from '../types/slate-editor'
-import {getFocusSpan} from './slate-utils'
-
-describe(getFocusSpan.name, () => {
-  const keyGenerator = createTestKeyGenerator()
-  const blockKey = keyGenerator()
-  const fooSpanKey = keyGenerator()
-  const stockTickerKey = keyGenerator()
-  const barSpanKey = keyGenerator()
-  const imageKey = keyGenerator()
-  const initialValue = [
-    {
-      _key: blockKey,
-      _type: 'block',
-      children: [
-        {
-          _type: 'span',
-          _key: fooSpanKey,
-          text: 'foo',
-        },
-        {
-          _type: 'stock-ticker',
-          _key: stockTickerKey,
-        },
-        {
-          _type: 'span',
-          _key: barSpanKey,
-          text: 'bar',
-        },
-      ],
-    },
-    {
-      _key: imageKey,
-      _type: 'image',
-    },
-  ]
-  const schemaDefinition = defineSchema({
-    blockObjects: [{name: 'image'}],
-    inlineObjects: [{name: 'stock-ticker'}],
-  })
-
-  test('Scenario: Text block span is selected', async () => {
-    const slateEditorRef = React.createRef<PortableTextSlateEditor>()
-    const {editor} = await createTestEditor({
-      children: <InternalSlateEditorRefPlugin ref={slateEditorRef} />,
-      schemaDefinition,
-      initialValue,
-    })
-
-    editor.send({
-      type: 'select',
-      at: {
-        anchor: {
-          path: [{_key: blockKey}, 'children', {_key: fooSpanKey}],
-          offset: 0,
-        },
-        focus: {
-          path: [{_key: blockKey}, 'children', {_key: fooSpanKey}],
-          offset: 0,
-        },
-      },
-    })
-
-    expect(getFocusSpan({editor: slateEditorRef.current!})).toEqual([
-      {_type: 'span', _key: fooSpanKey, text: 'foo', marks: []},
-      [0, 0],
-    ])
-  })
-
-  test('Scenario: Inline object is selected', async () => {
-    const slateEditorRef = React.createRef<PortableTextSlateEditor>()
-    await createTestEditor({
-      children: <InternalSlateEditorRefPlugin ref={slateEditorRef} />,
-      schemaDefinition,
-      initialValue,
-      editableProps: {
-        selection: {
-          anchor: {
-            path: [{_key: blockKey}, 'children', {_key: stockTickerKey}],
-            offset: 0,
-          },
-          focus: {
-            path: [{_key: blockKey}, 'children', {_key: stockTickerKey}],
-            offset: 0,
-          },
-        },
-      },
-    })
-
-    expect(getFocusSpan({editor: slateEditorRef.current!})).toEqual([
-      undefined,
-      undefined,
-    ])
-  })
-
-  test('Scenario: Block object is selected', async () => {
-    const slateEditorRef = React.createRef<PortableTextSlateEditor>()
-    await createTestEditor({
-      children: <InternalSlateEditorRefPlugin ref={slateEditorRef} />,
-      schemaDefinition,
-      initialValue,
-      editableProps: {
-        selection: {
-          anchor: {path: [{_key: imageKey}], offset: 0},
-          focus: {path: [{_key: imageKey}], offset: 0},
-        },
-      },
-    })
-
-    expect(getFocusSpan({editor: slateEditorRef.current!})).toEqual([
-      undefined,
-      undefined,
-    ])
-  })
-})