@portabletext/editor 3.3.3 → 3.3.4

package/src/editor/use-editor.ts

@@ -1,27 +0,0 @@
-import React from 'react'
-import {EditorContext} from './editor-context'
-
-/**
- * @public
- * Get the current editor context from the `EditorProvider`.
- * Must be used inside the `EditorProvider` component.
- * @returns The current editor object.
- * @example
- * ```tsx
- * import { useEditor } from '@portabletext/editor'
- *
- * function MyComponent() {
- *  const editor = useEditor()
- * }
- * ```
- * @group Hooks
- */
-export function useEditor() {
-  const editor = React.useContext(EditorContext)
-
-  if (!editor) {
-    throw new Error('No Editor set. Use EditorProvider to set one.')
-  }
-
-  return editor
-}

package/src/editor/validate-selection-machine.test.ts

@@ -1,47 +0,0 @@
-import {getTersePt} from '@portabletext/test'
-import {describe, expect, test, vi} from 'vitest'
-import {userEvent} from 'vitest/browser'
-import {getSelectionAfterText} from '../internal-utils/text-selection'
-import {createTestEditor} from '../test/vitest'
-import {validateSelectionMachine} from './validate-selection-machine'
-
-describe(validateSelectionMachine.id, () => {
-  test('Scenario: Does not validate selection while Slate has pending operations', async () => {
-    const {editor, locator} = await createTestEditor()
-
-    await userEvent.click(locator)
-
-    editor.send({type: 'insert.text', text: 'foo'})
-
-    await vi.waitFor(() => {
-      expect(getTersePt(editor.getSnapshot().context)).toEqual(['foo'])
-      expect(editor.getSnapshot().context.selection).toEqual(
-        getSelectionAfterText(editor.getSnapshot().context, 'foo'),
-      )
-    })
-
-    // This event is being sent in before "foo" has been inserted in the DOM
-    // This means that when the MutationObserver is finally triggered for the
-    // "foo" insertion, "bar" will be in the Slate state but not in the DOM.
-    // This causes the selection to be out of sync and this is why we need to
-    // make sure the selection is not validated before Slate has committed all
-    // pending operations.
-    editor.send({type: 'insert.text', text: 'bar'})
-
-    await vi.waitFor(() => {
-      expect(getTersePt(editor.getSnapshot().context)).toEqual(['foobar'])
-      expect(editor.getSnapshot().context.selection).toEqual(
-        getSelectionAfterText(editor.getSnapshot().context, 'foobar'),
-      )
-    })
-
-    editor.send({type: 'delete.backward', unit: 'character'})
-
-    await vi.waitFor(() => {
-      expect(getTersePt(editor.getSnapshot().context)).toEqual(['fooba'])
-      expect(editor.getSnapshot().context.selection).toEqual(
-        getSelectionAfterText(editor.getSnapshot().context, 'fooba'),
-      )
-    })
-  })
-})

package/src/editor/validate-selection-machine.ts

@@ -1,149 +0,0 @@
-import {Editor, Transforms} from 'slate'
-import {ReactEditor} from 'slate-react'
-import {setup} from 'xstate'
-import {debugWithName} from '../internal-utils/debug'
-import type {PortableTextSlateEditor} from '../types/slate-editor'
-
-const debug = debugWithName('validate selection machine')
-
-const validateSelectionSetup = setup({
-  types: {
-    context: {} as {
-      slateEditor: PortableTextSlateEditor
-    },
-    input: {} as {
-      slateEditor: PortableTextSlateEditor
-    },
-    events: {} as {
-      type: 'validate selection'
-      editorElement: HTMLDivElement
-    },
-  },
-  guards: {
-    'pending operations': ({context}) =>
-      context.slateEditor.operations.length > 0,
-  },
-})
-
-const validateSelectionAction = validateSelectionSetup.createAction(
-  ({context, event}) => {
-    validateSelection(context.slateEditor, event.editorElement)
-  },
-)
-
-export const validateSelectionMachine = validateSelectionSetup.createMachine({
-  id: 'validate selection',
-  context: ({input}) => ({
-    slateEditor: input.slateEditor,
-  }),
-  initial: 'idle',
-  states: {
-    idle: {
-      on: {
-        'validate selection': [
-          {
-            guard: 'pending operations',
-            target: 'waiting',
-          },
-          {
-            actions: [validateSelectionAction],
-            target: 'idle',
-          },
-        ],
-      },
-    },
-    waiting: {
-      after: {
-        0: [
-          {
-            guard: 'pending operations',
-            target: '.',
-            reenter: true,
-          },
-          {
-            target: 'idle',
-            actions: [validateSelectionAction],
-          },
-        ],
-      },
-      on: {
-        'validate selection': {
-          target: '.',
-          reenter: true,
-        },
-      },
-    },
-  },
-})
-
-// This function will handle unexpected DOM changes inside the Editable rendering,
-// and make sure that we can maintain a stable slateEditor.selection when that happens.
-//
-// For example, if this Editable is rendered inside something that might re-render
-// this component (hidden contexts) while the user is still actively changing the
-// contentEditable, this could interfere with the intermediate DOM selection,
-// which again could be picked up by ReactEditor's event listeners.
-// If that range is invalid at that point, the slate.editorSelection could be
-// set either wrong, or invalid, to which slateEditor will throw exceptions
-// that are impossible to recover properly from or result in a wrong selection.
-//
-// Also the other way around, when the ReactEditor will try to create a DOM Range
-// from the current slateEditor.selection, it may throw unrecoverable errors
-// if the current editor.selection is invalid according to the DOM.
-// If this is the case, default to selecting the top of the document, if the
-// user already had a selection.
-function validateSelection(
-  slateEditor: PortableTextSlateEditor,
-  editorElement: HTMLDivElement,
-) {
-  if (!slateEditor.selection) {
-    return
-  }
-
-  let root: Document | ShadowRoot | undefined
-
-  try {
-    root = ReactEditor.findDocumentOrShadowRoot(slateEditor)
-  } catch {}
-
-  if (!root) {
-    // The editor has most likely been unmounted
-    return
-  }
-
-  // Return if the editor isn't the active element
-  if (editorElement !== root.activeElement) {
-    return
-  }
-  const window = ReactEditor.getWindow(slateEditor)
-  const domSelection = window.getSelection()
-  if (!domSelection || domSelection.rangeCount === 0) {
-    return
-  }
-  const existingDOMRange = domSelection.getRangeAt(0)
-  try {
-    const newDOMRange = ReactEditor.toDOMRange(
-      slateEditor,
-      slateEditor.selection,
-    )
-    if (
-      newDOMRange.startOffset !== existingDOMRange.startOffset ||
-      newDOMRange.endOffset !== existingDOMRange.endOffset
-    ) {
-      debug('DOM range out of sync, validating selection')
-      // Remove all ranges temporary
-      domSelection?.removeAllRanges()
-      // Set the correct range
-      domSelection.addRange(newDOMRange)
-    }
-  } catch {
-    debug(`Could not resolve selection, selecting top document`)
-    // Deselect the editor
-    Transforms.deselect(slateEditor)
-    // Select top document if there is a top block to select
-    if (slateEditor.children.length > 0) {
-      Transforms.select(slateEditor, Editor.start(slateEditor, []))
-    }
-    slateEditor.onChange()
-  }
-}

package/src/editor/weakMaps.ts

@@ -1,15 +0,0 @@
-import type {Editor, Range} from 'slate'
-import type {EditorSelection} from '../types/editor'
-
-// Is the editor currently receiving remote changes that are being applied to the content?
-export const IS_PROCESSING_REMOTE_CHANGES: WeakMap<Editor, boolean> =
-  new WeakMap()
-
-export const KEY_TO_SLATE_ELEMENT: WeakMap<Editor, any | undefined> =
-  new WeakMap()
-
-// Keep object relation to slate range in the portable-text-range
-export const SLATE_TO_PORTABLE_TEXT_RANGE = new WeakMap<
-  Range,
-  EditorSelection
->()

package/src/editor/with-normalizing-node.ts

@@ -1,14 +0,0 @@
-import type {Editor} from 'slate'
-
-const IS_NORMALIZING_NODE: WeakMap<Editor, boolean | undefined> = new WeakMap()
-
-export function withNormalizeNode(editor: Editor, fn: () => void) {
-  const prev = IS_NORMALIZING_NODE.get(editor)
-  IS_NORMALIZING_NODE.set(editor, true)
-  fn()
-  IS_NORMALIZING_NODE.set(editor, prev)
-}
-
-export function isNormalizingNode(editor: Editor) {
-  return IS_NORMALIZING_NODE.get(editor) ?? false
-}

package/src/editor/with-performing-behavior-operation.ts

@@ -1,21 +0,0 @@
-import type {Editor} from 'slate'
-
-const IS_PERFORMING_OPERATION: WeakMap<Editor, boolean | undefined> =
-  new WeakMap()
-
-export function withPerformingBehaviorOperation(
-  editor: Editor,
-  fn: () => void,
-) {
-  const prev = IS_PERFORMING_OPERATION.get(editor)
-
-  IS_PERFORMING_OPERATION.set(editor, true)
-
-  fn()
-
-  IS_PERFORMING_OPERATION.set(editor, prev)
-}
-
-export function isPerformingBehaviorOperation(editor: Editor) {
-  return IS_PERFORMING_OPERATION.get(editor) ?? false
-}

package/src/editor/withChanges.ts

@@ -1,13 +0,0 @@
-import type {Editor} from 'slate'
-import {IS_PROCESSING_REMOTE_CHANGES} from './weakMaps'
-
-export function withRemoteChanges(editor: Editor, fn: () => void): void {
-  const prev = isChangingRemotely(editor) || false
-  IS_PROCESSING_REMOTE_CHANGES.set(editor, true)
-  fn()
-  IS_PROCESSING_REMOTE_CHANGES.set(editor, prev)
-}
-
-export function isChangingRemotely(editor: Editor): boolean | undefined {
-  return IS_PROCESSING_REMOTE_CHANGES.get(editor)
-}

package/src/editor/without-normalizing-conditional.ts

@@ -1,13 +0,0 @@
-import {Editor} from 'slate'
-
-export function withoutNormalizingConditional(
-  editor: Editor,
-  predicate: () => boolean,
-  fn: () => void,
-) {
-  if (predicate()) {
-    Editor.withoutNormalizing(editor, fn)
-  } else {
-    fn()
-  }
-}

package/src/editor/withoutPatching.ts

@@ -1,14 +0,0 @@
-import type {Editor} from 'slate'
-
-export const PATCHING: WeakMap<Editor, boolean | undefined> = new WeakMap()
-
-export function withoutPatching(editor: Editor, fn: () => void): void {
-  const prev = isPatching(editor)
-  PATCHING.set(editor, false)
-  fn()
-  PATCHING.set(editor, prev)
-}
-
-export function isPatching(editor: Editor): boolean | undefined {
-  return PATCHING.get(editor)
-}

package/src/editor.ts

@@ -1,59 +0,0 @@
-import type {SchemaDefinition} from '@portabletext/schema'
-import type {
-  ArrayDefinition,
-  ArraySchemaType,
-  PortableTextBlock,
-} from '@sanity/types'
-import type {ActorRef, EventObject, Snapshot} from 'xstate'
-import type {Behavior} from './behaviors/behavior.types.behavior'
-import type {ExternalBehaviorEvent} from './behaviors/behavior.types.event'
-import type {EditorDom} from './editor/editor-dom'
-import type {ExternalEditorEvent} from './editor/editor-machine'
-import type {EditorSnapshot} from './editor/editor-snapshot'
-import type {EditorEmittedEvent} from './editor/relay-machine'
-
-/**
- * @public
- */
-export type EditorConfig = {
-  /**
-   * @beta
-   */
-  keyGenerator?: () => string
-  readOnly?: boolean
-  initialValue?: Array<PortableTextBlock>
-} & (
-  | {
-      schemaDefinition: SchemaDefinition
-      schema?: undefined
-    }
-  | {
-      schemaDefinition?: undefined
-      schema: ArraySchemaType<PortableTextBlock> | ArrayDefinition
-    }
-)
-
-/**
- * @public
- */
-export type EditorEvent =
-  | ExternalEditorEvent
-  | ExternalBehaviorEvent
-  | {
-      type: 'update value'
-      value: Array<PortableTextBlock> | undefined
-    }
-
-/**
- * @public
- */
-export type Editor = {
-  dom: EditorDom
-  getSnapshot: () => EditorSnapshot
-  /**
-   * @beta
-   */
-  registerBehavior: (config: {behavior: Behavior}) => () => void
-  send: (event: EditorEvent) => void
-  on: ActorRef<Snapshot<unknown>, EventObject, EditorEmittedEvent>['on']
-}

package/src/history/behavior.operation.history.redo.ts

@@ -1,67 +0,0 @@
-import {flatten} from 'lodash'
-import {Editor, Transforms} from 'slate'
-import {debugWithName} from '../internal-utils/debug'
-import type {BehaviorOperationImplementation} from '../operations/behavior.operations'
-import {getRemotePatches} from './remote-patches'
-import {pluginRedoing, setIsRedoing} from './slate-plugin.redoing'
-import {
-  pluginWithoutHistory,
-  setWithHistory,
-} from './slate-plugin.without-history'
-import {transformOperation} from './transform-operation'
-
-const debug = debugWithName('behavior.operation.history.redo')
-
-export const historyRedoOperationImplementation: BehaviorOperationImplementation<
-  'history.redo'
-> = ({operation}) => {
-  const editor = operation.editor
-  const {redos} = editor.history
-  const remotePatches = getRemotePatches(editor)
-
-  if (redos.length > 0) {
-    const step = redos[redos.length - 1]
-    debug('Redoing', step)
-    if (step.operations.length > 0) {
-      const otherPatches = remotePatches.filter(
-        (item) => item.time >= step.timestamp,
-      )
-      let transformedOperations = step.operations
-      otherPatches.forEach((item) => {
-        transformedOperations = flatten(
-          transformedOperations.map((op) =>
-            transformOperation(
-              editor,
-              item.patch,
-              op,
-              item.snapshot,
-              item.previousSnapshot,
-            ),
-          ),
-        )
-      })
-      try {
-        Editor.withoutNormalizing(editor, () => {
-          pluginRedoing(editor, () => {
-            pluginWithoutHistory(editor, () => {
-              transformedOperations.forEach((op) => {
-                editor.apply(op)
-              })
-            })
-          })
-        })
-      } catch (err) {
-        debug('Could not perform redo step', err)
-        remotePatches.splice(0, remotePatches.length)
-        Transforms.deselect(editor)
-        editor.history = {undos: [], redos: []}
-        setWithHistory(editor, true)
-        setIsRedoing(editor, false)
-        editor.onChange()
-        return
-      }
-      editor.history.undos.push(step)
-      editor.history.redos.pop()
-    }
-  }
-}

package/src/history/behavior.operation.history.undo.ts

@@ -1,71 +0,0 @@
-import {flatten} from 'lodash'
-import {Editor, Operation, Transforms} from 'slate'
-import {debugWithName} from '../internal-utils/debug'
-import type {BehaviorOperationImplementation} from '../operations/behavior.operations'
-import {getRemotePatches} from './remote-patches'
-import {pluginUndoing, setIsUndoing} from './slate-plugin.undoing'
-import {
-  pluginWithoutHistory,
-  setWithHistory,
-} from './slate-plugin.without-history'
-import {transformOperation} from './transform-operation'
-
-const debug = debugWithName('behavior.operation.history.undo')
-
-export const historyUndoOperationImplementation: BehaviorOperationImplementation<
-  'history.undo'
-> = ({operation}) => {
-  const editor = operation.editor
-  const {undos} = editor.history
-  const remotePatches = getRemotePatches(editor)
-
-  if (undos.length > 0) {
-    const step = undos[undos.length - 1]
-    debug('Undoing', step)
-    if (step.operations.length > 0) {
-      const otherPatches = remotePatches.filter(
-        (item) => item.time >= step.timestamp,
-      )
-      let transformedOperations = step.operations
-      otherPatches.forEach((item) => {
-        transformedOperations = flatten(
-          transformedOperations.map((op) =>
-            transformOperation(
-              editor,
-              item.patch,
-              op,
-              item.snapshot,
-              item.previousSnapshot,
-            ),
-          ),
-        )
-      })
-      const reversedOperations = transformedOperations
-        .map(Operation.inverse)
-        .reverse()
-
-      try {
-        Editor.withoutNormalizing(editor, () => {
-          pluginUndoing(editor, () => {
-            pluginWithoutHistory(editor, () => {
-              reversedOperations.forEach((op) => {
-                editor.apply(op)
-              })
-            })
-          })
-        })
-      } catch (err) {
-        debug('Could not perform undo step', err)
-        remotePatches.splice(0, remotePatches.length)
-        Transforms.deselect(editor)
-        editor.history = {undos: [], redos: []}
-        setWithHistory(editor, true)
-        setIsUndoing(editor, false)
-        editor.onChange()
-        return
-      }
-      editor.history.redos.push(step)
-      editor.history.undos.pop()
-    }
-  }
-}