@portabletext/editor 3.3.3 → 3.3.4

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

@@ -1,417 +0,0 @@
-import type {PortableTextSpan} from '@sanity/types'
-import {Editor, Element, Node, Range, type Path, type Point} from 'slate'
-import type {EditorSchema} from '../editor/editor-schema'
-import type {EditorSelection} from '../types/editor'
-import type {PortableTextSlateEditor} from '../types/slate-editor'
-import {fromSlateBlock} from './values'
-
-export function getBlockPath({
-  editor,
-  _key,
-}: {
-  editor: PortableTextSlateEditor
-  _key: string
-}): [number] | undefined {
-  const [, blockPath] = Array.from(
-    Editor.nodes(editor, {
-      at: [],
-      match: (n) => n._key === _key,
-    }),
-  ).at(0) ?? [undefined, undefined]
-
-  const blockIndex = blockPath?.at(0)
-
-  if (blockIndex === undefined) {
-    return undefined
-  }
-
-  return [blockIndex]
-}
-
-export function getAnchorBlock({
-  editor,
-}: {
-  editor: PortableTextSlateEditor
-}): [node: Node, path: Path] | [undefined, undefined] {
-  if (!editor.selection) {
-    return [undefined, undefined]
-  }
-
-  try {
-    return (
-      Editor.node(editor, editor.selection.anchor.path.slice(0, 1)) ?? [
-        undefined,
-        undefined,
-      ]
-    )
-  } catch {
-    return [undefined, undefined]
-  }
-}
-
-export function getFocusBlock({
-  editor,
-}: {
-  editor: PortableTextSlateEditor
-}): [node: Node, path: Path] | [undefined, undefined] {
-  if (!editor.selection) {
-    return [undefined, undefined]
-  }
-
-  try {
-    return (
-      Editor.node(editor, editor.selection.focus.path.slice(0, 1)) ?? [
-        undefined,
-        undefined,
-      ]
-    )
-  } catch {
-    return [undefined, undefined]
-  }
-}
-
-export function getFocusSpan({
-  editor,
-}: {
-  editor: PortableTextSlateEditor
-}): [node: PortableTextSpan, path: Path] | [undefined, undefined] {
-  if (!editor.selection) {
-    return [undefined, undefined]
-  }
-
-  try {
-    const [focusBlock] = getFocusBlock({editor})
-
-    if (!focusBlock) {
-      return [undefined, undefined]
-    }
-
-    if (!editor.isTextBlock(focusBlock)) {
-      return [undefined, undefined]
-    }
-
-    const [node, path] = Editor.node(
-      editor,
-      editor.selection.focus.path.slice(0, 2),
-    )
-
-    if (editor.isTextSpan(node)) {
-      return [node, path]
-    }
-  } catch {
-    return [undefined, undefined]
-  }
-
-  return [undefined, undefined]
-}
-
-export function getSelectionStartBlock({
-  editor,
-}: {
-  editor: PortableTextSlateEditor
-}): [node: Node, path: Path] | [undefined, undefined] {
-  if (!editor.selection) {
-    return [undefined, undefined]
-  }
-
-  const selectionStartPoint = Range.start(editor.selection)
-
-  return getPointBlock({editor, point: selectionStartPoint})
-}
-
-export function getSelectionEndBlock({
-  editor,
-}: {
-  editor: PortableTextSlateEditor
-}): [node: Node, path: Path] | [undefined, undefined] {
-  if (!editor.selection) {
-    return [undefined, undefined]
-  }
-
-  const selectionEndPoint = Range.end(editor.selection)
-
-  return getPointBlock({editor, point: selectionEndPoint})
-}
-
-export function getPointBlock({
-  editor,
-  point,
-}: {
-  editor: PortableTextSlateEditor
-  point: Point
-}): [node: Node, path: Path] | [undefined, undefined] {
-  try {
-    const [block] = Editor.node(editor, point.path.slice(0, 1)) ?? [
-      undefined,
-      undefined,
-    ]
-    return block ? [block, point.path.slice(0, 1)] : [undefined, undefined]
-  } catch {
-    return [undefined, undefined]
-  }
-}
-
-export function getFocusChild({
-  editor,
-}: {
-  editor: PortableTextSlateEditor
-}): [node: Node, path: Path] | [undefined, undefined] {
-  const [focusBlock, focusBlockPath] = getFocusBlock({editor})
-  const childIndex = editor.selection?.focus.path.at(1)
-
-  if (!focusBlock || !focusBlockPath || childIndex === undefined) {
-    return [undefined, undefined]
-  }
-
-  try {
-    const focusChild = Node.child(focusBlock, childIndex)
-
-    return focusChild
-      ? [focusChild, [...focusBlockPath, childIndex]]
-      : [undefined, undefined]
-  } catch {
-    return [undefined, undefined]
-  }
-}
-
-function getPointChild({
-  editor,
-  point,
-}: {
-  editor: PortableTextSlateEditor
-  point: Point
-}): [node: Node, path: Path] | [undefined, undefined] {
-  const [block, blockPath] = getPointBlock({editor, point})
-  const childIndex = point.path.at(1)
-
-  if (!block || !blockPath || childIndex === undefined) {
-    return [undefined, undefined]
-  }
-
-  try {
-    const pointChild = Node.child(block, childIndex)
-
-    return pointChild
-      ? [pointChild, [...blockPath, childIndex]]
-      : [undefined, undefined]
-  } catch {
-    return [undefined, undefined]
-  }
-}
-
-export function getFirstBlock({
-  editor,
-}: {
-  editor: PortableTextSlateEditor
-}): [node: Node, path: Path] | [undefined, undefined] {
-  if (editor.children.length === 0) {
-    return [undefined, undefined]
-  }
-
-  const firstPoint = Editor.start(editor, [])
-  const firstBlockPath = firstPoint.path.at(0)
-
-  try {
-    return firstBlockPath !== undefined
-      ? (Editor.node(editor, [firstBlockPath]) ?? [undefined, undefined])
-      : [undefined, undefined]
-  } catch {
-    return [undefined, undefined]
-  }
-}
-
-export function getLastBlock({
-  editor,
-}: {
-  editor: PortableTextSlateEditor
-}): [node: Node, path: Path] | [undefined, undefined] {
-  if (editor.children.length === 0) {
-    return [undefined, undefined]
-  }
-
-  const lastPoint = Editor.end(editor, [])
-  const lastBlockPath = lastPoint.path.at(0)
-
-  try {
-    return lastBlockPath !== undefined
-      ? (Editor.node(editor, [lastBlockPath]) ?? [undefined, undefined])
-      : [undefined, undefined]
-  } catch {
-    return [undefined, undefined]
-  }
-}
-
-export function getNodeBlock({
-  editor,
-  schema,
-  node,
-}: {
-  editor: PortableTextSlateEditor
-  schema: EditorSchema
-  node: Node
-}) {
-  if (Editor.isEditor(node)) {
-    return undefined
-  }
-
-  if (isBlockElement({editor, schema}, node)) {
-    return elementToBlock({schema, element: node})
-  }
-
-  const parent = Array.from(
-    Editor.nodes(editor, {
-      mode: 'highest',
-      at: [],
-      match: (n) =>
-        isBlockElement({editor, schema}, n) &&
-        n.children.some((child) => child._key === node._key),
-    }),
-  )
-    .at(0)
-    ?.at(0)
-
-  return Element.isElement(parent)
-    ? elementToBlock({
-        schema,
-        element: parent,
-      })
-    : undefined
-}
-
-function elementToBlock({
-  schema,
-  element,
-}: {
-  schema: EditorSchema
-  element: Element
-}) {
-  return fromSlateBlock(element, schema.block.name)
-}
-
-function isBlockElement(
-  {editor, schema}: {editor: PortableTextSlateEditor; schema: EditorSchema},
-  node: Node,
-): node is Element {
-  return (
-    Element.isElement(node) &&
-    !editor.isInline(node) &&
-    (schema.block.name === node._type ||
-      schema.blockObjects.some(
-        (blockObject) => blockObject.name === node._type,
-      ))
-  )
-}
-
-export function isListItemActive({
-  editor,
-  listItem,
-}: {
-  editor: Editor
-  listItem: string
-}): boolean {
-  if (!editor.selection) {
-    return false
-  }
-
-  const selectedBlocks = [
-    ...Editor.nodes(editor, {
-      at: editor.selection,
-      match: (node) => editor.isTextBlock(node),
-    }),
-  ]
-
-  if (selectedBlocks.length > 0) {
-    return selectedBlocks.every(
-      ([node]) => editor.isListBlock(node) && node.listItem === listItem,
-    )
-  }
-
-  return false
-}
-
-export function isStyleActive({
-  editor,
-  style,
-}: {
-  editor: Editor
-  style: string
-}): boolean {
-  if (!editor.selection) {
-    return false
-  }
-
-  const selectedBlocks = [
-    ...Editor.nodes(editor, {
-      at: editor.selection,
-      match: (node) => editor.isTextBlock(node),
-    }),
-  ]
-
-  if (selectedBlocks.length > 0) {
-    return selectedBlocks.every(([node]) => node.style === style)
-  }
-
-  return false
-}
-
-export function slateRangeToSelection({
-  schema,
-  editor,
-  range,
-}: {
-  schema: EditorSchema
-  editor: PortableTextSlateEditor
-  range: Range
-}): EditorSelection {
-  const [anchorBlock] = getPointBlock({
-    editor,
-    point: range.anchor,
-  })
-  const [focusBlock] = getPointBlock({
-    editor,
-    point: range.focus,
-  })
-
-  if (!anchorBlock || !focusBlock) {
-    return null
-  }
-
-  const [anchorChild] =
-    anchorBlock._type === schema.block.name
-      ? getPointChild({
-          editor,
-          point: range.anchor,
-        })
-      : [undefined, undefined]
-  const [focusChild] =
-    focusBlock._type === schema.block.name
-      ? getPointChild({
-          editor,
-          point: range.focus,
-        })
-      : [undefined, undefined]
-
-  const selection: EditorSelection = {
-    anchor: {
-      path: [{_key: anchorBlock._key}],
-      offset: range.anchor.offset,
-    },
-    focus: {
-      path: [{_key: focusBlock._key}],
-      offset: range.focus.offset,
-    },
-    backward: Range.isBackward(range),
-  }
-
-  if (anchorChild) {
-    selection.anchor.path.push('children')
-    selection.anchor.path.push({_key: anchorChild._key})
-  }
-
-  if (focusChild) {
-    selection.focus.path.push('children')
-    selection.focus.path.push({_key: focusChild._key})
-  }
-
-  return selection
-}

package/src/internal-utils/split-string.ts

@@ -1,12 +0,0 @@
-export function splitString(string: string, searchString: string) {
-  const searchStringIndex = string.indexOf(searchString)
-
-  if (searchStringIndex === -1) {
-    return [string, ''] as const
-  }
-
-  const firstPart = string.slice(0, searchStringIndex)
-  const secondPart = string.slice(searchStringIndex + searchString.length)
-
-  return [firstPart, secondPart] as const
-}

package/src/internal-utils/stop-actor.ts

@@ -1,43 +0,0 @@
-/**
- * Copy/pasted from https://github.com/statelyai/xstate/blob/main/packages/xstate-react/src/stopRootWithRehydration.ts
- * and renamed to `stopActor`
- */
-
-import type {AnyActorRef, Snapshot} from 'xstate'
-
-const forEachActor = (
-  actorRef: AnyActorRef,
-  callback: (ref: AnyActorRef) => void,
-) => {
-  callback(actorRef)
-  const children = actorRef.getSnapshot().children
-  if (children) {
-    Object.values(children).forEach((child) => {
-      forEachActor(child as AnyActorRef, callback)
-    })
-  }
-}
-
-export function stopActor(actorRef: AnyActorRef) {
-  // persist snapshot here in a custom way allows us to persist inline actors and to preserve actor references
-  // we do it to avoid setState in useEffect when the effect gets "reconnected"
-  // this currently only happens in Strict Effects but it simulates the Offscreen aka Activity API
-  // it also just allows us to end up with a somewhat more predictable behavior for the users
-  const persistedSnapshots: Array<[AnyActorRef, Snapshot<unknown>]> = []
-  forEachActor(actorRef, (ref) => {
-    persistedSnapshots.push([ref, ref.getSnapshot()])
-    // muting observers allow us to avoid `useSelector` from being notified about the stopped snapshot
-    // React reconnects its subscribers (from the useSyncExternalStore) on its own
-    // and userland subscibers should basically always do the same anyway
-    // as each subscription should have its own cleanup logic and that should be called each such reconnect
-    ;(ref as any).observers = new Set()
-  })
-  const systemSnapshot = actorRef.system.getSnapshot?.()
-
-  actorRef.stop()
-  ;(actorRef.system as any)._snapshot = systemSnapshot
-  persistedSnapshots.forEach(([ref, snapshot]) => {
-    ;(ref as any)._processingStatus = 0
-    ;(ref as any)._snapshot = snapshot
-  })
-}

package/src/internal-utils/string-overlap.test.ts

@@ -1,14 +0,0 @@
-import {expect, test} from 'vitest'
-import {stringOverlap} from './string-overlap'
-
-test(stringOverlap.name, () => {
-  expect(stringOverlap('', 'foobar')).toBe('')
-  expect(stringOverlap('foo ', 'o bar b')).toBe('o ')
-  expect(stringOverlap('foo', 'o')).toBe('o')
-  expect(stringOverlap('foo bar baz', 'o')).toBe('o')
-  expect(stringOverlap('bar', 'o bar b')).toBe('bar')
-  expect(stringOverlap(' baz', 'o bar b')).toBe(' b')
-  expect(stringOverlap('fofofo', 'fo')).toBe('fo')
-  expect(stringOverlap('fofofo', 'fof')).toBe('fof')
-  expect(stringOverlap('fofofo', 'fofofof')).toBe('fofofo')
-})

package/src/internal-utils/string-overlap.ts

@@ -1,28 +0,0 @@
-export function stringOverlap(x: string, y: string) {
-  let overlap = ''
-
-  const [string, searchString] = y.length >= x.length ? [x, y] : [y, x]
-
-  for (let i = -1; i > -string.length + -searchString.length; i--) {
-    if (i >= -string.length) {
-      const stringSlice = string.slice(0, i * -1)
-      const searchStringSlice = searchString.slice(i)
-
-      if (stringSlice === searchStringSlice) {
-        overlap = stringSlice.length > overlap.length ? stringSlice : overlap
-      }
-    } else {
-      const searchStringSlice = searchString.slice(i, i + string.length)
-      const stringSlice =
-        searchStringSlice.length === string.length
-          ? string
-          : string.slice(string.length - searchStringSlice.length)
-
-      if (stringSlice === searchStringSlice) {
-        overlap = stringSlice.length > overlap.length ? stringSlice : overlap
-      }
-    }
-  }
-
-  return overlap
-}

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

@@ -1,7 +0,0 @@
-export function splitString(string: string, searchString: string) {
-  const index = string.indexOf(searchString)
-  if (index === -1) {
-    return [string, '']
-  }
-  return [string.slice(0, index), string.slice(index + searchString.length)]
-}

package/src/internal-utils/text-block-key.test.ts

@@ -1,41 +0,0 @@
-import {compileSchema, defineSchema} from '@portabletext/schema'
-import {expect, test} from 'vitest'
-import {getTextBlockKey} from './text-block-key'
-
-test(getTextBlockKey.name, () => {
-  const schema = compileSchema(defineSchema({}))
-  const emptyBlock = {
-    _key: 'b1',
-    _type: 'block',
-    children: [{_key: 's1', _type: 'span', text: ''}],
-  }
-  const fooBlock = {
-    _key: 'b2',
-    _type: 'block',
-    children: [{_key: 's2', _type: 'span', text: 'foo'}],
-  }
-  const softReturnBlock = {
-    _key: 'b3',
-    _type: 'block',
-    children: [{_key: 's3', _type: 'span', text: 'foo\nbar'}],
-  }
-
-  expect(
-    getTextBlockKey(
-      {schema, value: [emptyBlock, fooBlock, softReturnBlock]},
-      '',
-    ),
-  ).toBe('b1')
-  expect(
-    getTextBlockKey(
-      {schema, value: [emptyBlock, fooBlock, softReturnBlock]},
-      'foo',
-    ),
-  ).toBe('b2')
-  expect(
-    getTextBlockKey(
-      {schema, value: [emptyBlock, fooBlock, softReturnBlock]},
-      'foo\nbar',
-    ),
-  ).toBe('b3')
-})

package/src/internal-utils/text-block-key.ts

@@ -1,26 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {EditorContext} from '../editor/editor-snapshot'
-
-export function getTextBlockKey(
-  context: Pick<EditorContext, 'schema' | 'value'>,
-  text: string,
-) {
-  let blockKey: string | undefined
-
-  for (const block of context.value) {
-    if (isTextBlock(context, block)) {
-      for (const child of block.children) {
-        if (isSpan(context, child) && child.text === text) {
-          blockKey = block._key
-          break
-        }
-      }
-    }
-  }
-
-  if (!blockKey) {
-    throw new Error(`Unable to find block key for text "${text}"`)
-  }
-
-  return blockKey
-}

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

@@ -1,41 +0,0 @@
-import {compileSchema, defineSchema} from '@portabletext/schema'
-import {expect, test} from 'vitest'
-import {getTextMarks} from './text-marks'
-
-test(getTextMarks.name, () => {
-  const schema = compileSchema(defineSchema({}))
-  const fooBlock = {
-    _key: 'b1',
-    _type: 'block',
-    children: [{_key: 's1', _type: 'span', text: 'foo'}],
-  }
-  const splitBarBlock = {
-    _key: 'b1',
-    _type: 'block',
-    children: [
-      {_key: 's1', _type: 'span', text: 'ba', marks: ['strong']},
-      {_key: 's2', _type: 'span', text: 'r'},
-    ],
-  }
-  const splitFooBarBazBlock = {
-    _key: 'b1',
-    _type: 'block',
-    children: [
-      {_key: 's1', _type: 'span', text: 'foo '},
-      {_key: 's2', _type: 'span', text: 'bar', marks: ['strong']},
-      {_key: 's3', _type: 'span', text: ' '},
-      {_key: 's4', _type: 'span', text: 'baz', marks: ['l1']},
-    ],
-  }
-
-  expect(
-    getTextMarks({schema, value: [fooBlock, splitBarBlock]}, 'ba'),
-  ).toEqual(['strong'])
-  expect(getTextMarks({schema, value: [splitFooBarBazBlock]}, 'bar')).toEqual([
-    'strong',
-  ])
-  expect(getTextMarks({schema, value: [splitFooBarBazBlock]}, ' ')).toEqual([])
-  expect(getTextMarks({schema, value: [splitFooBarBazBlock]}, 'baz')).toEqual([
-    'l1',
-  ])
-})

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

@@ -1,22 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {EditorContext} from '../editor/editor-snapshot'
-
-export function getTextMarks(
-  context: Pick<EditorContext, 'schema' | 'value'>,
-  text: string,
-) {
-  let marks: Array<string> = []
-
-  for (const block of context.value) {
-    if (isTextBlock(context, block)) {
-      for (const child of block.children) {
-        if (isSpan(context, child) && child.text === text) {
-          marks = child.marks ?? []
-          break
-        }
-      }
-    }
-  }
-
-  return marks
-}