@portabletext/editor 2.1.9 → 2.1.11

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 react22 from "react";
 import React from "react";
 /**
  * @beta
@@ -181,7 +181,7 @@ type MarkdownPluginConfig = MarkdownBehaviorsConfig & {
  */
 declare function MarkdownPlugin(props: {
   config: MarkdownPluginConfig;
-}): react12.JSX.Element;
+}): react22.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(): react22.JSX.Element;
 export { BehaviorPlugin, DecoratorShortcutPlugin, EditorRefPlugin, EventListenerPlugin, MarkdownPlugin, type MarkdownPluginConfig, OneLinePlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "2.1.9",
+  "version": "2.1.11",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -78,15 +78,15 @@
     "slate": "0.118.0",
     "slate-dom": "^0.117.4",
     "slate-react": "0.117.4",
-    "xstate": "^5.20.1",
-    "@portabletext/block-tools": "2.0.7",
+    "xstate": "^5.20.2",
+    "@portabletext/block-tools": "2.0.8",
     "@portabletext/patches": "1.1.6",
     "@portabletext/keyboard-shortcuts": "1.1.1"
   },
   "devDependencies": {
     "@portabletext/toolkit": "^2.0.17",
     "@sanity/diff-match-patch": "^3.2.0",
-    "@sanity/pkg-utils": "^7.9.21",
+    "@sanity/pkg-utils": "^7.11.1",
     "@sanity/schema": "^4.3.0",
     "@sanity/types": "^4.3.0",
     "@testing-library/react": "^16.3.0",
@@ -95,8 +95,8 @@
     "@types/lodash.startcase": "^4.4.9",
     "@types/react": "^19.1.9",
     "@types/react-dom": "^19.1.7",
-    "@typescript-eslint/eslint-plugin": "^8.38.0",
-    "@typescript-eslint/parser": "^8.38.0",
+    "@typescript-eslint/eslint-plugin": "^8.39.0",
+    "@typescript-eslint/parser": "^8.39.0",
     "@vitejs/plugin-react": "^4.7.0",
     "@vitest/browser": "^3.2.4",
     "@vitest/coverage-istanbul": "^3.2.4",

package/src/editor/plugins/createWithEditableAPI.ts

@@ -424,7 +424,7 @@ export function createEditableAPI(
       return isActiveAnnotation(annotationType)(snapshot)
     },
     addAnnotation: (type, value) => {
-      let paths: ReturnType<EditableAPI['addAnnotation']> = undefined
+      let paths: ReturnType<EditableAPI['addAnnotation']>
 
       Editor.withoutNormalizing(editor, () => {
         paths = addAnnotationOperationImplementation({

package/src/internal-utils/applyPatch.ts

@@ -298,7 +298,7 @@ function setPatch(editor: PortableTextSlateEditor, patch: SetPatch) {
     return true
   } else if (Element.isElement(block.node) && patch.path.length === 1) {
     const {children, ...nextRest} = value as unknown as PortableTextBlock
-    const {children: prevChildren, ...prevRest} = block.node || {
+    const {children: _prevChildren, ...prevRest} = block.node || {
       children: undefined,
     }
 

package/src/internal-utils/build-index-maps.test.ts

@@ -187,6 +187,58 @@ describe(buildIndexMaps.name, () => {
     )
   })
 
+  test('numbered list broken up by a nested bulleted list', () => {
+    buildIndexMaps(
+      {
+        schema,
+        value: [
+          textBlock('k0', {listItem: 'number', level: 1}),
+          textBlock('k1', {listItem: 'number', level: 1}),
+          textBlock('k2', {listItem: 'bullet', level: 1}),
+          textBlock('k3', {listItem: 'bullet', level: 2}),
+          textBlock('k4', {listItem: 'number', level: 1}),
+        ],
+      },
+      {blockIndexMap, listIndexMap},
+    )
+    expect(listIndexMap).toEqual(
+      new Map([
+        ['k0', 1],
+        ['k1', 2],
+        ['k2', 1],
+        ['k3', 1],
+        ['k4', 1],
+      ]),
+    )
+  })
+
+  test('numbered list broken up by an inverse-indented bulleted list', () => {
+    buildIndexMaps(
+      {
+        schema,
+        value: [
+          textBlock('k0', {listItem: 'number', level: 1}),
+          textBlock('k1', {listItem: 'number', level: 1}),
+          textBlock('k2', {listItem: 'bullet', level: 2}),
+          textBlock('k3', {listItem: 'bullet', level: 1}),
+          textBlock('k4', {listItem: 'bullet', level: 2}),
+          textBlock('k5', {listItem: 'number', level: 1}),
+        ],
+      },
+      {blockIndexMap, listIndexMap},
+    )
+    expect(listIndexMap).toEqual(
+      new Map([
+        ['k0', 1],
+        ['k1', 2],
+        ['k2', 1],
+        ['k3', 1],
+        ['k4', 1],
+        ['k5', 1],
+      ]),
+    )
+  })
+
   test('simple indented list', () => {
     buildIndexMaps(
       {

package/src/internal-utils/build-index-maps.ts

@@ -1,7 +1,9 @@
 import type {EditorContext} from '../editor/editor-snapshot'
 import {isTextBlock} from './parse-blocks'
 
-const levelIndexMap = new Map<number, number>()
+// Maps for each list type, keeping track of the current list count for each
+// level.
+const levelIndexMaps = new Map<string, Map<number, number>>()
 
 /**
  * Mutates the maps in place.
@@ -18,7 +20,7 @@ export function buildIndexMaps(
 ): void {
   blockIndexMap.clear()
   listIndexMap.clear()
-  levelIndexMap.clear()
+  levelIndexMaps.clear()
 
   let previousListItem:
     | {
@@ -36,71 +38,82 @@ export function buildIndexMaps(
 
     blockIndexMap.set(block._key, blockIndex)
 
+    // Clear the state if we encounter a non-text block
     if (!isTextBlock(context, block)) {
-      levelIndexMap.clear()
+      levelIndexMaps.clear()
       previousListItem = undefined
+
       continue
     }
 
+    // Clear the state if we encounter a non-list text block
     if (block.listItem === undefined || block.level === undefined) {
-      levelIndexMap.clear()
+      levelIndexMaps.clear()
       previousListItem = undefined
+
       continue
     }
 
+    // If we encounter a new list item, we set the initial index to 1 for the
+    // list type on that level.
     if (!previousListItem) {
+      const listIndex = 1
+      const levelIndexMap =
+        levelIndexMaps.get(block.listItem) ?? new Map<number, number>()
+      levelIndexMap.set(block.level, listIndex)
+      levelIndexMaps.set(block.listItem, levelIndexMap)
+
+      listIndexMap.set(block._key, listIndex)
+
       previousListItem = {
         listItem: block.listItem,
         level: block.level,
       }
-      levelIndexMap.set(block.level, 1)
-      listIndexMap.set(block._key, 1)
+
       continue
     }
 
+    // If the previous list item is of the same type but on a lower level, we
+    // need to reset the level index map for that type.
     if (
-      previousListItem.listItem !== block.listItem &&
-      previousListItem.level === block.level
+      previousListItem.listItem === block.listItem &&
+      previousListItem.level < block.level
     ) {
-      levelIndexMap.clear()
-      previousListItem = {
-        listItem: block.listItem,
-        level: block.level,
-      }
-      levelIndexMap.set(block.level, 1)
-      listIndexMap.set(block._key, 1)
-      continue
-    }
+      const listIndex = 1
+      const levelIndexMap =
+        levelIndexMaps.get(block.listItem) ?? new Map<number, number>()
+      levelIndexMap.set(block.level, listIndex)
+      levelIndexMaps.set(block.listItem, levelIndexMap)
 
-    if (previousListItem.level === block.level) {
-      const levelCounter = levelIndexMap.get(block.level) ?? 0
-      levelIndexMap.set(block.level, levelCounter + 1)
-      previousListItem = {
-        listItem: block.listItem,
-        level: block.level,
-      }
-      listIndexMap.set(block._key, levelCounter + 1)
-      continue
-    }
+      listIndexMap.set(block._key, listIndex)
 
-    if (previousListItem.level < block.level) {
-      levelIndexMap.set(block.level, 1)
       previousListItem = {
         listItem: block.listItem,
         level: block.level,
       }
-      listIndexMap.set(block._key, 1)
+
       continue
     }
 
-    if (previousListItem.level > block.level) {
-      const levelCounter = levelIndexMap.get(block.level) ?? 0
-      levelIndexMap.set(block.level, levelCounter + 1)
-      previousListItem = {
-        listItem: block.listItem,
-        level: block.level,
+    // Reset all other list items on this level
+    levelIndexMaps.forEach((levelIndexMap, listItem) => {
+      if (listItem === block.listItem) {
+        return
       }
-      listIndexMap.set(block._key, levelCounter + 1)
+
+      levelIndexMap.set(block.level!, 0)
+    })
+
+    const levelIndexMap =
+      levelIndexMaps.get(block.listItem) ?? new Map<number, number>()
+    const levelCounter = levelIndexMap.get(block.level) ?? 0
+    levelIndexMap.set(block.level, levelCounter + 1)
+
+    listIndexMap.set(block._key, levelCounter + 1)
+
+    previousListItem = {
+      listItem: block.listItem,
+      level: block.level,
     }
   }
 }

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

@@ -9,7 +9,7 @@ export function getTextMarks(
     return undefined
   }
 
-  let marks: Array<string> | undefined = undefined
+  let marks: Array<string> | undefined
 
   for (const block of value) {
     if (isPortableTextBlock(block)) {

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

@@ -136,7 +136,7 @@ function toSlateSelectionPoint(
   let offset = spanSelectionPoint?.offset ?? selectionPoint.offset
   let childPath: Array<number> = []
   let childIndex = -1
-  let pathChild: PortableTextSpan | PortableTextObject | undefined = undefined
+  let pathChild: PortableTextSpan | PortableTextObject | undefined
 
   for (const child of block.children) {
     childIndex++

package/src/operations/behavior.operation.annotation.add.ts

@@ -46,7 +46,7 @@ export const addAnnotationOperationImplementation: BehaviorOperationImplementati
     return
   }
 
-  let paths: AddedAnnotationPaths | undefined = undefined
+  let paths: AddedAnnotationPaths | undefined
   let spanPath: Path | undefined
   let markDefPath: Path | undefined
   const markDefPaths: Path[] = []