@portabletext/editor 2.6.9 → 2.7.0

package/lib/plugins/index.d.ts

@@ -1,5 +1,5 @@
 import { Behavior, Editor, EditorEmittedEvent, EditorSchema } from "../_chunks-dts/behavior.types.action.js";
-import * as react12 from "react";
+import * as react21 from "react";
 import React from "react";
 /**
  * @beta
@@ -181,7 +181,7 @@ type MarkdownPluginConfig = MarkdownBehaviorsConfig & {
  */
 declare function MarkdownPlugin(props: {
   config: MarkdownPluginConfig;
-}): react12.JSX.Element;
+}): react21.JSX.Element;
 /**
  * @beta
  * Restrict the editor to one line. The plugin takes care of blocking
@@ -192,5 +192,5 @@ declare function MarkdownPlugin(props: {
  *
  * @deprecated Install the plugin from `@portabletext/plugin-one-line`
  */
-declare function OneLinePlugin(): react12.JSX.Element;
+declare function OneLinePlugin(): react21.JSX.Element;
 export { BehaviorPlugin, DecoratorShortcutPlugin, EditorRefPlugin, EventListenerPlugin, MarkdownPlugin, type MarkdownPluginConfig, OneLinePlugin };

package/lib/utils/index.d.cts

@@ -1,5 +1,5 @@
 import { BlockOffset, BlockPath, ChildPath, EditorContext, EditorSelection, EditorSelectionPoint } from "../_chunks-dts/behavior.types.action.cjs";
-import * as _sanity_types8 from "@sanity/types";
+import * as _sanity_types9 from "@sanity/types";
 import { KeyedSegment, PortableTextBlock, PortableTextTextBlock } from "@sanity/types";
 import { isSpan, isTextBlock } from "@portabletext/schema";
 /**
@@ -143,7 +143,7 @@ declare function mergeTextBlocks({
   context: Pick<EditorContext, 'keyGenerator' | 'schema'>;
   targetBlock: PortableTextTextBlock;
   incomingBlock: PortableTextTextBlock;
-}): PortableTextTextBlock<_sanity_types8.PortableTextObject | _sanity_types8.PortableTextSpan>;
+}): PortableTextTextBlock<_sanity_types9.PortableTextObject | _sanity_types9.PortableTextSpan>;
 /**
  * @public
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "2.6.9",
+  "version": "2.7.0",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -74,19 +74,19 @@
     "immer": "^10.1.1",
     "lodash": "^4.17.21",
     "lodash.startcase": "^4.4.0",
-    "react-compiler-runtime": "19.1.0-rc.2",
+    "react-compiler-runtime": "19.1.0-rc.3",
     "slate": "0.118.1",
     "slate-dom": "^0.118.1",
     "slate-react": "0.117.4",
     "xstate": "^5.21.0",
     "@portabletext/block-tools": "^3.5.1",
     "@portabletext/keyboard-shortcuts": "^1.1.1",
-    "@portabletext/schema": "^1.2.0",
-    "@portabletext/patches": "^1.1.8"
+    "@portabletext/patches": "^1.1.8",
+    "@portabletext/schema": "^1.2.0"
   },
   "devDependencies": {
     "@sanity/diff-match-patch": "^3.2.0",
-    "@sanity/pkg-utils": "^8.1.1",
+    "@sanity/pkg-utils": "^8.1.4",
     "@sanity/schema": "^4.6.0",
     "@sanity/types": "^4.6.0",
     "@testing-library/react": "^16.3.0",
@@ -95,19 +95,19 @@
     "@types/lodash.startcase": "^4.4.9",
     "@types/react": "^19.1.11",
     "@types/react-dom": "^19.1.7",
-    "@typescript-eslint/eslint-plugin": "^8.39.1",
-    "@typescript-eslint/parser": "^8.39.1",
     "@vitejs/plugin-react": "^4.7.0",
     "@vitest/browser": "^3.2.4",
     "@vitest/coverage-istanbul": "^3.2.4",
-    "babel-plugin-react-compiler": "19.1.0-rc.2",
-    "eslint": "8.57.1",
-    "eslint-plugin-react-hooks": "6.0.0-rc.1",
+    "babel-plugin-react-compiler": "19.1.0-rc.3",
+    "eslint": "^9.34.0",
+    "eslint-formatter-gha": "^1.6.0",
+    "eslint-plugin-react-hooks": "6.0.0-rc.2",
     "jsdom": "^26.0.0",
     "react": "^19.1.1",
     "react-dom": "^19.1.1",
     "rxjs": "^7.8.2",
     "typescript": "5.9.2",
+    "typescript-eslint": "^8.41.0",
     "vite": "^7.1.3",
     "vitest": "^3.2.4",
     "vitest-browser-react": "^1.0.1",
@@ -131,7 +131,7 @@
   "scripts": {
     "build": "pkg-utils build --strict --check --clean",
     "check:lint": "biome lint .",
-    "check:react-compiler": "eslint --cache --no-inline-config --no-eslintrc --ignore-pattern '**/__tests__/**' --ext .cjs,.mjs,.js,.jsx,.ts,.tsx --parser @typescript-eslint/parser --plugin react-hooks --rule 'react-hooks/react-compiler: [error]' --rule 'react-hooks/rules-of-hooks: [error]' --rule 'react-hooks/exhaustive-deps: [error]' src",
+    "check:react-compiler": "eslint --cache .",
     "check:types": "tsc",
     "check:types:watch": "tsc --watch",
     "clean": "del .turbo && del lib && del node_modules",

package/src/editor/editor-provider.tsx

@@ -1,9 +1,8 @@
 import type React from 'react'
-import {useEffect} from 'react'
+import {useEffect, useState} from 'react'
 import {Slate} from 'slate-react'
 import type {EditorConfig} from '../editor'
 import {stopActor} from '../internal-utils/stop-actor'
-import useConstant from '../internal-utils/use-constant'
 import {createInternalEditor} from './create-editor'
 import {EditorActorContext} from './editor-actor-context'
 import {EditorContext} from './editor-context'
@@ -42,7 +41,7 @@ export type EditorProviderProps = {
  * @group Components
  */
 export function EditorProvider(props: EditorProviderProps) {
-  const {internalEditor, portableTextEditor} = useConstant(() => {
+  const [{internalEditor, portableTextEditor}] = useState(() => {
     const internalEditor = createInternalEditor(props.initialConfig)
     const portableTextEditor = new PortableTextEditor({
       editor: internalEditor.editor,

package/src/selectors/selector.is-overlapping-selection.test.ts

@@ -170,6 +170,122 @@ describe(isOverlappingSelection.name, () => {
     ).toBe(false)
   })
 
+  test('partial span selection', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 0},
+        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
+          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
+        }),
+      ),
+    ).toBe(true)
+  })
+
+  test('expanded selection at the end edge of span', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 0},
+        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
+          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
+        }),
+      ),
+    ).toBe(false)
+  })
+
+  test('collapsed selection at the end edge of span', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 0},
+        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
+          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
+        }),
+      ),
+    ).toBe(true)
+  })
+
+  test('expanded selection at the start edge of span', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 0},
+        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 3},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
+          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 0},
+        }),
+      ),
+    ).toBe(false)
+  })
+
+  test('collapsed selection at the start edge of span', () => {
+    expect(
+      isOverlappingSelection({
+        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 0},
+        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 3},
+      })(
+        snapshot({
+          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 0},
+          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 0},
+        }),
+      ),
+    ).toBe(true)
+  })
+
+  test('selecting entire span', () => {
+    const blockKey = defaultKeyGenerator()
+    const fooKey = defaultKeyGenerator()
+    const barKey = defaultKeyGenerator()
+    const bazKey = defaultKeyGenerator()
+
+    expect(
+      isOverlappingSelection({
+        anchor: {
+          path: [{_key: blockKey}, 'children', {_key: barKey}],
+          offset: 0,
+        },
+        focus: {
+          path: [{_key: blockKey}, 'children', {_key: barKey}],
+          offset: 3,
+        },
+      })(
+        createTestSnapshot({
+          context: {
+            value: [
+              {
+                _key: blockKey,
+                _type: 'block',
+                children: [
+                  {_key: fooKey, _type: 'span', text: 'foo'},
+                  {_key: barKey, _type: 'span', text: 'bar', marks: ['strong']},
+                  {_key: bazKey, _type: 'span', text: 'baz'},
+                ],
+              },
+            ],
+            selection: {
+              anchor: {
+                path: [{_key: blockKey}, 'children', {_key: barKey}],
+                offset: 0,
+              },
+              focus: {
+                path: [{_key: blockKey}, 'children', {_key: barKey}],
+                offset: 3,
+              },
+            },
+          },
+        }),
+      ),
+    ).toBe(true)
+  })
+
   test('unknown block', () => {
     const unknownBlockKey = defaultKeyGenerator()
 

package/src/selectors/selector.is-overlapping-selection.ts

@@ -44,6 +44,22 @@ export function isOverlappingSelection(
       return false
     }
 
+    const startPointEqualToOriginalStartPoint = isEqualSelectionPoints(
+      selectionStartPoint,
+      originalSelectionStartPoint,
+    )
+    const endPointEqualToOriginalEndPoint = isEqualSelectionPoints(
+      selectionEndPoint,
+      originalSelectionEndPoint,
+    )
+
+    if (
+      startPointEqualToOriginalStartPoint &&
+      endPointEqualToOriginalEndPoint
+    ) {
+      return true
+    }
+
     const startPointBeforeSelection =
       isPointBeforeSelection(selectionStartPoint)(snapshot)
     const startPointAfterSelection =
@@ -103,14 +119,14 @@ export function isOverlappingSelection(
       },
     })
 
-    const endPointEqualToOriginalStartPoint = isEqualSelectionPoints(
-      selectionEndPoint,
-      originalSelectionStartPoint,
-    )
     const startPointEqualToOriginalEndPoint = isEqualSelectionPoints(
       selectionStartPoint,
       originalSelectionEndPoint,
     )
+    const endPointEqualToOriginalStartPoint = isEqualSelectionPoints(
+      selectionEndPoint,
+      originalSelectionStartPoint,
+    )
 
     // If all checks fail then we can deduce that the selection does not exist
     // and there doesn't overlap with the snapshot selection

package/src/internal-utils/use-constant.ts

@@ -1,15 +0,0 @@
-import React from 'react'
-
-type ConstantRef<TConstant> = {constant: TConstant}
-
-export default function useConstant<TConstant>(
-  factory: () => TConstant,
-): TConstant {
-  const ref = React.useRef<ConstantRef<TConstant>>(null)
-
-  if (!ref.current) {
-    ref.current = {constant: factory()}
-  }
-
-  return ref.current.constant
-}