@portabletext/editor 3.3.2 → 3.3.4

package/src/operations/behavior.operation.select.ts

@@ -1,27 +0,0 @@
-import {Transforms} from 'slate'
-import {IS_FOCUSED, IS_READ_ONLY} from 'slate-dom'
-import {toSlateRange} from '../internal-utils/to-slate-range'
-import type {BehaviorOperationImplementation} from './behavior.operations'
-
-export const selectOperationImplementation: BehaviorOperationImplementation<
-  'select'
-> = ({context, operation}) => {
-  const newSelection = toSlateRange({
-    context: {
-      schema: context.schema,
-      value: operation.editor.value,
-      selection: operation.at,
-    },
-    blockIndexMap: operation.editor.blockIndexMap,
-  })
-
-  if (newSelection) {
-    Transforms.select(operation.editor, newSelection)
-  } else {
-    Transforms.deselect(operation.editor)
-  }
-
-  if (IS_FOCUSED.get(operation.editor) && IS_READ_ONLY.get(operation.editor)) {
-    IS_FOCUSED.set(operation.editor, false)
-  }
-}

package/src/operations/behavior.operations.ts

@@ -1,221 +0,0 @@
-import {Editor} from 'slate'
-import type {
-  AbstractBehaviorEventType,
-  SyntheticBehaviorEvent,
-} from '../behaviors/behavior.types.event'
-import type {EditorContext} from '../editor/editor-snapshot'
-import {removeDecoratorOperationImplementation} from '../editor/plugins/createWithPortableTextMarkModel'
-import {historyRedoOperationImplementation} from '../history/behavior.operation.history.redo'
-import {historyUndoOperationImplementation} from '../history/behavior.operation.history.undo'
-import type {OmitFromUnion, PickFromUnion} from '../type-utils'
-import type {PortableTextSlateEditor} from '../types/slate-editor'
-import {addAnnotationOperationImplementation} from './behavior.operation.annotation.add'
-import {removeAnnotationOperationImplementation} from './behavior.operation.annotation.remove'
-import {blockSetOperationImplementation} from './behavior.operation.block.set'
-import {blockUnsetOperationImplementation} from './behavior.operation.block.unset'
-import {childSetOperationImplementation} from './behavior.operation.child.set'
-import {childUnsetOperationImplementation} from './behavior.operation.child.unset'
-import {decoratorAddOperationImplementation} from './behavior.operation.decorator.add'
-import {deleteOperationImplementation} from './behavior.operation.delete'
-import {insertBlockOperationImplementation} from './behavior.operation.insert.block'
-import {insertChildOperationImplementation} from './behavior.operation.insert.child'
-import {insertTextOperationImplementation} from './behavior.operation.insert.text'
-import {moveBackwardOperationImplementation} from './behavior.operation.move.backward'
-import {moveBlockOperationImplementation} from './behavior.operation.move.block'
-import {moveForwardOperationImplementation} from './behavior.operation.move.forward'
-import {selectOperationImplementation} from './behavior.operation.select'
-
-export type BehaviorOperationImplementationContext = Pick<
-  EditorContext,
-  'keyGenerator' | 'schema'
->
-
-export type BehaviorOperationImplementation<
-  TBehaviorOperationType extends BehaviorOperation['type'],
-> = ({
-  context,
-  operation,
-}: {
-  context: BehaviorOperationImplementationContext
-  operation: PickFromUnion<BehaviorOperation, 'type', TBehaviorOperationType>
-}) => void
-
-type BehaviorOperation = OmitFromUnion<
-  SyntheticBehaviorEvent,
-  'type',
-  AbstractBehaviorEventType
-> & {
-  editor: PortableTextSlateEditor
-}
-
-type BehaviorOperationImplementations = {
-  [TBehaviorOperationType in BehaviorOperation['type']]: BehaviorOperationImplementation<TBehaviorOperationType>
-}
-
-const behaviorOperationImplementations: BehaviorOperationImplementations = {
-  'annotation.add': addAnnotationOperationImplementation,
-  'annotation.remove': removeAnnotationOperationImplementation,
-  'block.set': blockSetOperationImplementation,
-  'block.unset': blockUnsetOperationImplementation,
-  'child.set': childSetOperationImplementation,
-  'child.unset': childUnsetOperationImplementation,
-  'decorator.add': decoratorAddOperationImplementation,
-  'decorator.remove': removeDecoratorOperationImplementation,
-  'delete': deleteOperationImplementation,
-  'history.redo': historyRedoOperationImplementation,
-  'history.undo': historyUndoOperationImplementation,
-  'insert.block': insertBlockOperationImplementation,
-  'insert.child': insertChildOperationImplementation,
-  'insert.text': insertTextOperationImplementation,
-  'move.backward': moveBackwardOperationImplementation,
-  'move.block': moveBlockOperationImplementation,
-  'move.forward': moveForwardOperationImplementation,
-  'select': selectOperationImplementation,
-}
-
-export function performOperation({
-  context,
-  operation,
-}: {
-  context: BehaviorOperationImplementationContext
-  operation: BehaviorOperation
-}) {
-  Editor.withoutNormalizing(operation.editor, () => {
-    try {
-      switch (operation.type) {
-        case 'annotation.add': {
-          behaviorOperationImplementations['annotation.add']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'annotation.remove': {
-          behaviorOperationImplementations['annotation.remove']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'block.set': {
-          behaviorOperationImplementations['block.set']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'block.unset': {
-          behaviorOperationImplementations['block.unset']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'child.set': {
-          behaviorOperationImplementations['child.set']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'child.unset': {
-          behaviorOperationImplementations['child.unset']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'decorator.add': {
-          behaviorOperationImplementations['decorator.add']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'decorator.remove': {
-          behaviorOperationImplementations['decorator.remove']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'delete': {
-          behaviorOperationImplementations.delete({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'history.redo': {
-          behaviorOperationImplementations['history.redo']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'history.undo': {
-          behaviorOperationImplementations['history.undo']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'insert.block': {
-          behaviorOperationImplementations['insert.block']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'insert.child': {
-          behaviorOperationImplementations['insert.child']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'insert.text': {
-          behaviorOperationImplementations['insert.text']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'move.backward': {
-          behaviorOperationImplementations['move.backward']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'move.block': {
-          behaviorOperationImplementations['move.block']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        case 'move.forward': {
-          behaviorOperationImplementations['move.forward']({
-            context,
-            operation: operation,
-          })
-          break
-        }
-        default: {
-          behaviorOperationImplementations.select({
-            context,
-            operation: operation,
-          })
-          break
-        }
-      }
-    } catch (error) {
-      console.error(
-        new Error(
-          `Executing "${operation.type}" failed due to: ${error.message}`,
-        ),
-      )
-    }
-  })
-}

package/src/plugins/_exports/index.ts

@@ -1 +0,0 @@
-export * from '../index'

package/src/plugins/index.ts

@@ -1,3 +0,0 @@
-export {BehaviorPlugin} from './plugin.behavior'
-export {EditorRefPlugin} from './plugin.editor-ref'
-export {EventListenerPlugin} from './plugin.event-listener'

package/src/plugins/plugin.behavior.tsx

@@ -1,24 +0,0 @@
-import {useEffect} from 'react'
-import type {Behavior} from '../behaviors/behavior.types.behavior'
-import {useEditor} from '../editor/use-editor'
-
-/**
- * @beta
- */
-export function BehaviorPlugin(props: {behaviors: Array<Behavior>}) {
-  const editor = useEditor()
-
-  useEffect(() => {
-    const unregisterBehaviors = props.behaviors.map((behavior) =>
-      editor.registerBehavior({behavior}),
-    )
-
-    return () => {
-      unregisterBehaviors.forEach((unregister) => {
-        unregister()
-      })
-    }
-  }, [editor, props.behaviors])
-
-  return null
-}

package/src/plugins/plugin.editor-ref.tsx

@@ -1,17 +0,0 @@
-import React from 'react'
-import type {Editor} from '../editor'
-import {useEditor} from '../editor/use-editor'
-
-/**
- * @beta
- */
-export const EditorRefPlugin = React.forwardRef<Editor | null>((_, ref) => {
-  const editor = useEditor()
-
-  const portableTextEditorRef = React.useRef(editor)
-
-  React.useImperativeHandle(ref, () => portableTextEditorRef.current, [])
-
-  return null
-})
-EditorRefPlugin.displayName = 'EditorRefPlugin'

package/src/plugins/plugin.event-listener.tsx

@@ -1,68 +0,0 @@
-import {useEffect} from 'react'
-import type {EditorEmittedEvent} from '../editor/relay-machine'
-import {useEditor} from '../editor/use-editor'
-
-/**
- * @public
- * Listen for events emitted by the editor. Must be used inside `EditorProvider`. Events available include:
- *  - 'blurred'
- *  - 'done loading'
- *  - 'editable'
- *  - 'error'
- *  - 'focused'
- *  - 'invalid value'
- *  - 'loading'
- *  - 'mutation'
- *  - 'patch'
- *  - 'read only'
- *  - 'ready'
- *  - 'selection'
- *  - 'value changed'
- *
- * @example
- * Listen and log events.
- * ```tsx
- * import {EditorProvider} from '@portabletext/editor'
- * import {EventListenerPlugin} from '@portabletext/editor/plugins'
- *
- * function MyComponent() {
- *  return (
- *  <EditorProvider>
- *   <EventListenerPlugin
- *    on={(event) => {
- *     console.log(event)
- *    }
- *   } />
- *   { ... }
- * </EditorProvider>
- *  )
- * }
- * ```
- * @example
- * Handle events when there is a mutation.
- * ```tsx
- * <EventListenerPlugin
- *  on={(event) => {
- *    if (event.type === 'mutation') {
- *      console.log('Value changed:', event.snapshot)
- *    }
- *  }}
- * />
- * ```
- * @group Components
- */
-export function EventListenerPlugin(props: {
-  on: (event: EditorEmittedEvent) => void
-}) {
-  const editor = useEditor()
-
-  useEffect(() => {
-    const subscription = editor.on('*', props.on)
-
-    return () => {
-      subscription.unsubscribe()
-    }
-  }, [editor, props.on])
-
-  return null
-}

package/src/plugins/plugin.internal.auto-close-brackets.test.tsx

@@ -1,71 +0,0 @@
-import {getTersePt} from '@portabletext/test'
-import {describe, expect, test, vi} from 'vitest'
-import {userEvent} from 'vitest/browser'
-import {createTestEditor} from '../test/vitest'
-import {AutoCloseBracketsPlugin} from './plugin.internal.auto-close-brackets'
-
-describe(AutoCloseBracketsPlugin.name, () => {
-  test('One-character text insertion', async () => {
-    const {editor, locator} = await createTestEditor({
-      children: <AutoCloseBracketsPlugin />,
-    })
-
-    await userEvent.click(locator)
-
-    editor.send({type: 'insert.text', text: '('})
-
-    await vi.waitFor(() => {
-      expect(getTersePt(editor.getSnapshot().context)).toEqual(['()'])
-    })
-
-    await userEvent.type(locator, 'foo')
-
-    await vi.waitFor(() => {
-      expect(getTersePt(editor.getSnapshot().context)).toEqual(['(foo)'])
-    })
-
-    editor.send({type: 'history.undo'})
-
-    await vi.waitFor(() => {
-      expect(getTersePt(editor.getSnapshot().context)).toEqual(['()'])
-    })
-
-    editor.send({type: 'history.undo'})
-
-    await vi.waitFor(() => {
-      expect(getTersePt(editor.getSnapshot().context)).toEqual(['('])
-    })
-  })
-
-  test('Two-character text insertion', async () => {
-    const {editor, locator} = await createTestEditor({
-      children: <AutoCloseBracketsPlugin />,
-    })
-
-    await userEvent.click(locator)
-
-    editor.send({type: 'insert.text', text: '(f'})
-
-    await vi.waitFor(() => {
-      expect(getTersePt(editor.getSnapshot().context)).toEqual(['(f)'])
-    })
-
-    await userEvent.type(locator, 'oo')
-
-    await vi.waitFor(() => {
-      expect(getTersePt(editor.getSnapshot().context)).toEqual(['(foo)'])
-    })
-
-    editor.send({type: 'history.undo'})
-
-    await vi.waitFor(() => {
-      expect(getTersePt(editor.getSnapshot().context)).toEqual(['(f)'])
-    })
-
-    editor.send({type: 'history.undo'})
-
-    await vi.waitFor(() => {
-      expect(getTersePt(editor.getSnapshot().context)).toEqual(['(f'])
-    })
-  })
-})

package/src/plugins/plugin.internal.auto-close-brackets.ts

@@ -1,62 +0,0 @@
-import {useEffect} from 'react'
-import {execute} from '../behaviors/behavior.types.action'
-import {defineBehavior} from '../behaviors/behavior.types.behavior'
-import {useEditor} from '../editor/use-editor'
-
-export function AutoCloseBracketsPlugin() {
-  const editor = useEditor()
-
-  useEffect(() => {
-    const unregisterBehavior = editor.registerBehavior({
-      behavior: defineBehavior({
-        on: 'insert.text',
-        guard: ({event}) => {
-          const bracketPairs: Record<string, string | undefined> = {
-            '(': ')',
-            '[': ']',
-            '{': '}',
-          }
-          const firstInsertedChar = event.text.at(0)
-          const closingBracket =
-            firstInsertedChar !== undefined
-              ? bracketPairs[firstInsertedChar]
-              : undefined
-
-          if (closingBracket !== undefined) {
-            // Passing the closing bracket to the actions for reuse
-            return {closingBracket}
-          }
-
-          return false
-        },
-        actions: [
-          ({event}) => [
-            // Execute the original event that includes the opening bracket
-            execute(event),
-          ],
-          /*
-           * New undo step so the auto-closing of the bracket can be undone.
-           * Notice how the step reuses the `closingBracket` derived in the `guard`.
-           */
-          (_, {closingBracket}) => [
-            // Execute a new `insert.text` event with a closing bracket
-            execute({
-              type: 'insert.text',
-              text: closingBracket,
-            }),
-            // Execute a `move.backward` event to move the cursor in between the brackets
-            execute({
-              type: 'move.backward',
-              distance: closingBracket.length,
-            }),
-          ],
-        ],
-      }),
-    })
-
-    return () => {
-      unregisterBehavior()
-    }
-  }, [editor])
-  return null
-}

package/src/plugins/plugin.internal.change-ref.tsx

@@ -1,19 +0,0 @@
-import {useEffect} from 'react'
-import {usePortableTextEditor} from '../editor/hooks/usePortableTextEditor'
-import type {EditorChange} from '../types/editor'
-
-export function InternalChange$Plugin(props: {
-  onChange: (change: EditorChange) => void
-}) {
-  const change$ = usePortableTextEditor().change$
-
-  useEffect(() => {
-    const subscription = change$.subscribe(props.onChange)
-
-    return () => {
-      subscription.unsubscribe()
-    }
-  }, [change$, props.onChange])
-
-  return null
-}

package/src/plugins/plugin.internal.portable-text-editor-ref.tsx

@@ -1,16 +0,0 @@
-import React from 'react'
-import {usePortableTextEditor} from '../editor/hooks/usePortableTextEditor'
-import type {PortableTextEditor} from '../editor/PortableTextEditor'
-
-export const InternalPortableTextEditorRefPlugin =
-  React.forwardRef<PortableTextEditor | null>((_, ref) => {
-    const portableTextEditor = usePortableTextEditor()
-
-    const portableTextEditorRef = React.useRef(portableTextEditor)
-
-    React.useImperativeHandle(ref, () => portableTextEditorRef.current, [])
-
-    return null
-  })
-InternalPortableTextEditorRefPlugin.displayName =
-  'InternalPortableTextEditorRefPlugin'

package/src/plugins/plugin.internal.slate-editor-ref.tsx

@@ -1,15 +0,0 @@
-import React from 'react'
-import {useSlateStatic} from 'slate-react'
-import type {PortableTextSlateEditor} from '../types/slate-editor'
-
-export const InternalSlateEditorRefPlugin =
-  React.forwardRef<PortableTextSlateEditor | null>((_, ref) => {
-    const slateEditor = useSlateStatic()
-
-    const slateEditorRef = React.useRef(slateEditor)
-
-    React.useImperativeHandle(ref, () => slateEditorRef.current, [])
-
-    return null
-  })
-InternalSlateEditorRefPlugin.displayName = 'InternalSlateEditorRefPlugin'

package/src/priority/priority.core.ts

@@ -1,3 +0,0 @@
-import {createEditorPriority} from './priority.types'
-
-export const corePriority = createEditorPriority({name: 'core'})