@portabletext/editor 3.3.2 → 3.3.4

package/src/history/undo-redo.test.tsx

@@ -1,195 +0,0 @@
-import {Before} from 'racejar'
-import {Feature} from 'racejar/vitest'
-import {defineSchema} from '..'
-import {defineBehavior, forward, raise} from '../behaviors'
-import {BehaviorPlugin} from '../plugins/plugin.behavior'
-import {getFocusTextBlock, isSelectionExpanded} from '../selectors'
-import {parameterTypes} from '../test'
-import {createTestEditor, stepDefinitions, type Context} from '../test/vitest'
-import undoRedoFeature from './undo-redo.feature?raw'
-
-Feature({
-  featureText: undoRedoFeature,
-  stepDefinitions,
-  parameterTypes,
-  hooks: [
-    Before(async (context: Context) => {
-      const {editor, locator} = await createTestEditor({
-        schemaDefinition: defineSchema({
-          annotations: [{name: 'link'}, {name: 'comment'}],
-        }),
-        children: (
-          <>
-            <ArrowTransformPlugin />
-            <CopyrightTransformPlugin />
-          </>
-        ),
-      })
-
-      context.locator = locator
-      context.editor = editor
-    }),
-  ],
-})
-
-/**
- * Native behavior to transform `>` into `→`.
- * Ony for testing purposes.
- */
-function ArrowTransformPlugin() {
-  return (
-    <BehaviorPlugin
-      behaviors={[
-        defineBehavior({
-          on: 'insert.text',
-          guard: ({snapshot, event}) => {
-            if (event.text !== '>' || isSelectionExpanded(snapshot)) {
-              return false
-            }
-
-            const focusTextBlock = getFocusTextBlock(snapshot)
-
-            if (!focusTextBlock) {
-              return false
-            }
-
-            return {focusTextBlock}
-          },
-          actions: [
-            ({event}) => [forward(event)],
-            ({snapshot}, {focusTextBlock}) => [
-              raise({
-                type: 'select',
-                at: {
-                  anchor: {
-                    path: focusTextBlock.path,
-                    offset: 0,
-                  },
-                  focus: {
-                    path: focusTextBlock.path,
-                    offset: 2,
-                  },
-                },
-              }),
-              raise({
-                type: 'delete',
-                at: {
-                  anchor: {
-                    path: focusTextBlock.path,
-                    offset: 0,
-                  },
-                  focus: {
-                    path: focusTextBlock.path,
-                    offset: 2,
-                  },
-                },
-              }),
-              raise({
-                type: 'insert.child',
-                child: {
-                  _type: snapshot.context.schema.span.name,
-                  text: '→',
-                  marks: [],
-                },
-              }),
-              raise({
-                type: 'select',
-                at: {
-                  anchor: {
-                    path: focusTextBlock.path,
-                    offset: 2,
-                  },
-                  focus: {
-                    path: focusTextBlock.path,
-                    offset: 2,
-                  },
-                },
-              }),
-            ],
-          ],
-        }),
-      ]}
-    />
-  )
-}
-
-/**
- * Native behavior to transform `(c)` into `©`.
- * Ony for testing purposes.
- */
-function CopyrightTransformPlugin() {
-  return (
-    <BehaviorPlugin
-      behaviors={[
-        defineBehavior({
-          on: 'insert.text',
-          guard: ({snapshot, event}) => {
-            if (event.text !== ')' || isSelectionExpanded(snapshot)) {
-              return false
-            }
-
-            const focusTextBlock = getFocusTextBlock(snapshot)
-
-            if (!focusTextBlock) {
-              return false
-            }
-
-            return {focusTextBlock}
-          },
-          actions: [
-            ({event}) => [forward(event)],
-            ({snapshot}, {focusTextBlock}) => [
-              raise({
-                type: 'select',
-                at: {
-                  anchor: {
-                    path: focusTextBlock.path,
-                    offset: 0,
-                  },
-                  focus: {
-                    path: focusTextBlock.path,
-                    offset: 3,
-                  },
-                },
-              }),
-              raise({
-                type: 'delete',
-                at: {
-                  anchor: {
-                    path: focusTextBlock.path,
-                    offset: 0,
-                  },
-                  focus: {
-                    path: focusTextBlock.path,
-                    offset: 3,
-                  },
-                },
-              }),
-              raise({
-                type: 'insert.child',
-                child: {
-                  _type: snapshot.context.schema.span.name,
-                  text: '©',
-                  marks: [],
-                },
-              }),
-              raise({
-                type: 'select',
-                at: {
-                  anchor: {
-                    path: focusTextBlock.path,
-                    offset: 3,
-                  },
-                  focus: {
-                    path: focusTextBlock.path,
-                    offset: 3,
-                  },
-                },
-              }),
-            ],
-          ],
-        }),
-      ]}
-    />
-  )
-}

package/src/history/undo-step.ts

@@ -1,148 +0,0 @@
-import {Path, type Editor, type Operation} from 'slate'
-import {isNormalizingNode} from '../editor/with-normalizing-node'
-import {defaultKeyGenerator} from '../utils/key-generator'
-
-const CURRENT_UNDO_STEP_ID: WeakMap<Editor, {undoStepId: string} | undefined> =
-  new WeakMap()
-
-export function getCurrentUndoStepId(editor: Editor) {
-  return CURRENT_UNDO_STEP_ID.get(editor)?.undoStepId
-}
-
-export function createUndoStepId(editor: Editor) {
-  CURRENT_UNDO_STEP_ID.set(editor, {
-    undoStepId: defaultKeyGenerator(),
-  })
-}
-
-export function clearUndoStepId(editor: Editor) {
-  CURRENT_UNDO_STEP_ID.set(editor, undefined)
-}
-
-type UndoStep = {
-  operations: Array<Operation>
-  timestamp: Date
-}
-
-export function createUndoSteps({
-  steps,
-  op,
-  editor,
-  currentUndoStepId,
-  previousUndoStepId,
-}: {
-  steps: Array<UndoStep>
-  op: Operation
-  editor: Editor
-  currentUndoStepId: string | undefined
-  previousUndoStepId: string | undefined
-}): Array<UndoStep> {
-  const lastStep = steps.at(-1)
-
-  if (!lastStep) {
-    return createNewStep(steps, op, editor)
-  }
-
-  if (editor.operations.length > 0) {
-    // The editor has operations in progress
-
-    if (currentUndoStepId === previousUndoStepId || isNormalizingNode(editor)) {
-      return mergeIntoLastStep(steps, lastStep, op)
-    }
-
-    return createNewStep(steps, op, editor)
-  }
-
-  if (
-    op.type === 'set_selection' &&
-    currentUndoStepId === undefined &&
-    previousUndoStepId !== undefined
-  ) {
-    // Selecting without undo step ID
-    return mergeIntoLastStep(steps, lastStep, op)
-  }
-
-  if (
-    op.type === 'set_selection' &&
-    currentUndoStepId !== undefined &&
-    previousUndoStepId !== undefined &&
-    previousUndoStepId !== currentUndoStepId
-  ) {
-    // Selecting with different undo step ID
-    return mergeIntoLastStep(steps, lastStep, op)
-  }
-
-  // Handle case when both IDs are undefined
-  if (currentUndoStepId === undefined && previousUndoStepId === undefined) {
-    if (op.type === 'set_selection') {
-      return mergeIntoLastStep(steps, lastStep, op)
-    }
-
-    const lastOp = lastStep.operations.at(-1)
-
-    if (
-      lastOp &&
-      op.type === 'insert_text' &&
-      lastOp.type === 'insert_text' &&
-      op.offset === lastOp.offset + lastOp.text.length &&
-      Path.equals(op.path, lastOp.path) &&
-      op.text !== ' '
-    ) {
-      return mergeIntoLastStep(steps, lastStep, op)
-    }
-
-    if (
-      lastOp &&
-      op.type === 'remove_text' &&
-      lastOp.type === 'remove_text' &&
-      op.offset + op.text.length === lastOp.offset &&
-      Path.equals(op.path, lastOp.path)
-    ) {
-      return mergeIntoLastStep(steps, lastStep, op)
-    }
-
-    return createNewStep(steps, op, editor)
-  }
-
-  return createNewStep(steps, op, editor)
-}
-
-function createNewStep(
-  steps: Array<UndoStep>,
-  op: Operation,
-  editor: Editor,
-): Array<UndoStep> {
-  const operations =
-    editor.selection === null
-      ? [op]
-      : [
-          {
-            type: 'set_selection' as const,
-            properties: {...editor.selection},
-            newProperties: {...editor.selection},
-          },
-          op,
-        ]
-
-  return [
-    ...steps,
-    {
-      operations,
-      timestamp: new Date(),
-    },
-  ]
-}
-
-function mergeIntoLastStep(
-  steps: Array<UndoStep>,
-  lastStep: UndoStep,
-  op: Operation,
-): Array<UndoStep> {
-  return [
-    ...steps.slice(0, -1),
-    {
-      timestamp: lastStep.timestamp,
-      operations: [...lastStep.operations, op],
-    },
-  ]
-}

package/src/index.ts

@@ -1,98 +0,0 @@
-export type {Patch} from '@portabletext/patches'
-export type {
-  PortableTextBlock,
-  PortableTextTextBlock,
-  PortableTextChild,
-  PortableTextObject,
-  PortableTextSpan,
-} from '@sanity/types'
-export type {Editor, EditorConfig, EditorEvent} from './editor'
-export {PortableTextEditable} from './editor/Editable'
-export type {PortableTextEditableProps} from './editor/Editable'
-export type {PatchesEvent} from './editor/editor-machine'
-export {
-  EditorProvider,
-  type EditorProviderProps,
-} from './editor/editor-provider'
-export type {
-  AnnotationSchemaType,
-  BlockObjectSchemaType,
-  DecoratorSchemaType,
-  InlineObjectSchemaType,
-  ListSchemaType,
-  StyleSchemaType,
-} from '@portabletext/schema'
-export type {EditorSchema} from './editor/editor-schema'
-export {
-  defineSchema,
-  type AnnotationDefinition,
-  type BaseDefinition,
-  type BlockObjectDefinition,
-  type DecoratorDefinition,
-  type FieldDefinition,
-  type InlineObjectDefinition,
-  type ListDefinition,
-  type SchemaDefinition,
-  type StyleDefinition,
-} from '@portabletext/schema'
-export {useEditorSelector, type EditorSelector} from './editor/editor-selector'
-export type {EditorContext, EditorSnapshot} from './editor/editor-snapshot'
-export {usePortableTextEditor} from './editor/hooks/usePortableTextEditor'
-export {usePortableTextEditorSelection} from './editor/hooks/usePortableTextEditorSelection'
-export {defaultKeyGenerator as keyGenerator} from './utils/key-generator'
-export {PortableTextEditor} from './editor/PortableTextEditor'
-export type {PortableTextEditorProps} from './editor/PortableTextEditor'
-export type {EditorEmittedEvent, MutationEvent} from './editor/relay-machine'
-export {useEditor} from './editor/use-editor'
-export type {AddedAnnotationPaths} from './types/editor'
-export type {BlockOffset} from './types/block-offset'
-export type {
-  BlockAnnotationRenderProps,
-  BlockChildRenderProps,
-  BlockDecoratorRenderProps,
-  BlockListItemRenderProps,
-  BlockRenderProps,
-  BlockStyleRenderProps,
-  BlurChange,
-  ConnectionChange,
-  EditableAPI,
-  EditableAPIDeleteOptions,
-  EditorChange,
-  EditorChanges,
-  EditorSelection,
-  EditorSelectionPoint,
-  ErrorChange,
-  FocusChange,
-  InvalidValue,
-  InvalidValueResolution,
-  LoadingChange,
-  MutationChange,
-  OnBeforeInputFn,
-  OnCopyFn,
-  OnPasteFn,
-  OnPasteResult,
-  OnPasteResultOrPromise,
-  PasteData,
-  PatchChange,
-  PatchObservable,
-  PortableTextMemberSchemaTypes,
-  RangeDecoration,
-  RangeDecorationOnMovedDetails,
-  ReadyChange,
-  RedoChange,
-  RenderAnnotationFunction,
-  RenderBlockFunction,
-  RenderChildFunction,
-  RenderDecoratorFunction,
-  RenderEditableFunction,
-  RenderListItemFunction,
-  RenderPlaceholderFunction,
-  RenderStyleFunction,
-  ScrollSelectionIntoViewFunction,
-  SelectionChange,
-  UndoChange,
-  UnsetChange,
-  ValueChange,
-} from './types/editor'
-export type {HotkeyOptions} from './types/options'
-export type {AnnotationPath, BlockPath, ChildPath} from './types/paths'

package/src/internal-utils/__tests__/ranges.test.ts

@@ -1,23 +0,0 @@
-import type {InsertTextOperation, Range} from 'slate'
-import {describe, expect, it} from 'vitest'
-import {moveRangeByOperation} from '../move-range-by-operation'
-
-describe('moveRangeByOperation', () => {
-  it('should move range when inserting text in front of it', () => {
-    const range: Range = {
-      anchor: {path: [0, 0], offset: 1},
-      focus: {path: [0, 0], offset: 3},
-    }
-    const operation: InsertTextOperation = {
-      type: 'insert_text',
-      path: [0, 0],
-      offset: 0,
-      text: 'foo',
-    }
-    const newRange = moveRangeByOperation(range, operation)
-    expect(newRange).toEqual({
-      anchor: {path: [0, 0], offset: 4},
-      focus: {path: [0, 0], offset: 6},
-    })
-  })
-})

package/src/internal-utils/__tests__/values.test.ts

@@ -1,110 +0,0 @@
-import {compileSchema, defineSchema} from '@portabletext/schema'
-import {describe, expect, it} from 'vitest'
-import {toSlateBlock} from '../values'
-
-const schemaTypes = compileSchema(defineSchema({}))
-
-describe(toSlateBlock.name, () => {
-  it('given type is custom with no custom properties, should include an empty text property in children and an empty value', () => {
-    const result = toSlateBlock(
-      {
-        _type: 'image',
-        _key: '123',
-      },
-      {schemaTypes},
-    )
-
-    expect(result).toMatchObject({
-      _key: '123',
-      _type: 'image',
-      children: [
-        {
-          text: '',
-        },
-      ],
-      value: {},
-    })
-  })
-
-  it('given type is block', () => {
-    const result = toSlateBlock(
-      {
-        _type: schemaTypes.block.name,
-        _key: '123',
-        children: [
-          {
-            _type: 'span',
-            _key: '1231',
-            text: '123',
-          },
-        ],
-      },
-      {schemaTypes},
-    )
-    expect(result).toEqual({
-      _key: '123',
-      _type: 'block',
-      children: [
-        {
-          _key: '1231',
-          _type: 'span',
-          text: '123',
-        },
-      ],
-    })
-  })
-
-  it('given type is block and has custom in children', () => {
-    const result = toSlateBlock(
-      {
-        _type: schemaTypes.block.name,
-        _key: '123',
-        children: [
-          {
-            _type: 'span',
-            _key: '1231',
-            text: '123',
-          },
-          {
-            _type: 'image',
-            _key: '1232',
-            asset: {
-              _ref: 'ref-123',
-            },
-          },
-        ],
-      },
-      {schemaTypes},
-    )
-
-    expect(result).toEqual({
-      _key: '123',
-      _type: 'block',
-      children: [
-        {
-          _key: '1231',
-          _type: 'span',
-          text: '123',
-        },
-        {
-          __inline: true,
-          _key: '1232',
-          _type: 'image',
-          children: [
-            {
-              _key: 'void-child',
-              _type: 'span',
-              marks: [],
-              text: '',
-            },
-          ],
-          value: {
-            asset: {
-              _ref: 'ref-123',
-            },
-          },
-        },
-      ],
-    })
-  })
-})