@portabletext/editor 3.3.3 → 3.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "3.3.3",
+  "version": "3.3.5",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -58,8 +58,7 @@
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "files": [
-    "lib",
-    "src"
+    "lib"
   ],
   "dependencies": {
     "@portabletext/to-html": "^4.0.1",
@@ -70,12 +69,15 @@
     "lodash": "^4.17.21",
     "lodash.startcase": "^4.4.0",
     "react-compiler-runtime": "^1.0.0",
+    "slate": "^0.120.0",
+    "slate-dom": "^0.119.0",
+    "slate-react": "^0.120.0",
     "xstate": "^5.24.0",
-    "@portabletext/block-tools": "^4.1.8",
-    "@portabletext/keyboard-shortcuts": "^2.1.0",
-    "@portabletext/markdown": "^1.0.3",
-    "@portabletext/patches": "^2.0.0",
-    "@portabletext/schema": "^2.0.0"
+    "@portabletext/block-tools": "^4.1.9",
+    "@portabletext/keyboard-shortcuts": "^2.1.1",
+    "@portabletext/markdown": "^1.0.4",
+    "@portabletext/patches": "^2.0.1",
+    "@portabletext/schema": "^2.0.1"
   },
   "devDependencies": {
     "@sanity/diff-match-patch": "^3.2.0",
@@ -98,20 +100,17 @@
     "react": "^19.2.1",
     "react-dom": "^19.2.1",
     "rxjs": "^7.8.2",
-    "slate": "^0.120.0",
-    "slate-dom": "^0.119.0",
-    "slate-react": "^0.120.0",
     "typescript": "5.9.3",
     "typescript-eslint": "^8.48.0",
     "vite": "^7.1.12",
     "vitest": "^4.0.14",
     "vitest-browser-react": "^2.0.2",
-    "@portabletext/sanity-bridge": "1.2.11",
-    "@portabletext/test": "^1.0.1",
-    "racejar": "2.0.0"
+    "@portabletext/sanity-bridge": "1.2.12",
+    "@portabletext/test": "^1.0.2",
+    "racejar": "2.0.1"
   },
   "peerDependencies": {
-    "@portabletext/sanity-bridge": "^1.2.11",
+    "@portabletext/sanity-bridge": "^1.2.12",
     "react": "^18.3 || ^19",
     "rxjs": "^7.8.2"
   },

package/src/behaviors/_exports/index.ts

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

package/src/behaviors/behavior.abstract.annotation.ts

@@ -1,77 +0,0 @@
-import {getFocusTextBlock} from '../selectors/selector.get-focus-text-block'
-import {isActiveAnnotation} from '../selectors/selector.is-active-annotation'
-import {raise} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-export const abstractAnnotationBehaviors = [
-  defineBehavior({
-    on: 'annotation.set',
-    guard: ({snapshot, event}) => {
-      const blockKey = event.at[0]._key
-      const markDefKey = event.at[2]._key
-
-      const block = getFocusTextBlock({
-        ...snapshot,
-        context: {
-          ...snapshot.context,
-          selection: {
-            anchor: {
-              path: [{_key: blockKey}],
-              offset: 0,
-            },
-            focus: {
-              path: [{_key: blockKey}],
-              offset: 0,
-            },
-          },
-        },
-      })
-
-      if (!block) {
-        return false
-      }
-
-      const updatedMarkDefs = block.node.markDefs?.map((markDef) => {
-        if (markDef._key === markDefKey) {
-          return {
-            ...markDef,
-            ...event.props,
-          }
-        }
-
-        return markDef
-      })
-
-      return {blockKey, updatedMarkDefs}
-    },
-    actions: [
-      (_, {blockKey, updatedMarkDefs}) => [
-        raise({
-          type: 'block.set',
-          at: [{_key: blockKey}],
-          props: {markDefs: updatedMarkDefs},
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'annotation.toggle',
-    guard: ({snapshot, event}) =>
-      isActiveAnnotation(event.annotation.name)(snapshot),
-    actions: [
-      ({event}) => [
-        raise({type: 'annotation.remove', annotation: event.annotation}),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'annotation.toggle',
-    guard: ({snapshot, event}) =>
-      !isActiveAnnotation(event.annotation.name)(snapshot),
-    actions: [
-      ({event}) => [
-        raise({type: 'annotation.add', annotation: event.annotation}),
-      ],
-    ],
-  }),
-]

package/src/behaviors/behavior.abstract.decorator.ts

@@ -1,39 +0,0 @@
-import {isActiveDecorator} from '../selectors/selector.is-active-decorator'
-import {raise} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-export const abstractDecoratorBehaviors = [
-  defineBehavior({
-    on: 'decorator.toggle',
-    guard: ({snapshot, event}) => isActiveDecorator(event.decorator)(snapshot),
-    actions: [
-      ({event}) => [
-        raise({type: 'decorator.remove', decorator: event.decorator}),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'decorator.toggle',
-    guard: ({snapshot, event}) => {
-      if (event.at) {
-        return !isActiveDecorator(event.decorator)({
-          ...snapshot,
-          context: {
-            ...snapshot.context,
-            selection: event.at,
-          },
-        })
-      }
-
-      return !isActiveDecorator(event.decorator)(snapshot)
-    },
-    actions: [
-      ({event}) => [
-        raise({
-          ...event,
-          type: 'decorator.add',
-        }),
-      ],
-    ],
-  }),
-]

package/src/behaviors/behavior.abstract.delete.ts

@@ -1,273 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import {getFocusChild} from '../selectors/selector.get-focus-child'
-import {getFocusTextBlock} from '../selectors/selector.get-focus-text-block'
-import {getNextBlock} from '../selectors/selector.get-next-block'
-import {getPreviousBlock} from '../selectors/selector.get-previous-block'
-import {isAtTheEndOfBlock} from '../selectors/selector.is-at-the-end-of-block'
-import {isAtTheStartOfBlock} from '../selectors/selector.is-at-the-start-of-block'
-import {getBlockEndPoint} from '../utils/util.get-block-end-point'
-import {getBlockStartPoint} from '../utils/util.get-block-start-point'
-import {isEmptyTextBlock} from '../utils/util.is-empty-text-block'
-import {raise} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-export const abstractDeleteBehaviors = [
-  defineBehavior({
-    on: 'delete.backward',
-    guard: ({snapshot}) => {
-      return snapshot.context.selection
-    },
-    actions: [
-      ({event}) => [
-        raise({
-          type: 'delete',
-          direction: 'backward',
-          unit: event.unit,
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'delete',
-    guard: ({snapshot, event}) => {
-      if (event.direction !== 'backward') {
-        return false
-      }
-
-      const previousBlock = getPreviousBlock(snapshot)
-      const focusTextBlock = getFocusTextBlock(snapshot)
-
-      if (!previousBlock || !focusTextBlock) {
-        return false
-      }
-
-      if (!isAtTheStartOfBlock(focusTextBlock)(snapshot)) {
-        return false
-      }
-
-      const previousBlockEndPoint = getBlockEndPoint({
-        context: snapshot.context,
-        block: previousBlock,
-      })
-
-      if (!isTextBlock(snapshot.context, previousBlock.node)) {
-        return false
-      }
-
-      return {previousBlockEndPoint, focusTextBlock}
-    },
-    actions: [
-      (_, {previousBlockEndPoint, focusTextBlock}) => [
-        raise({
-          type: 'delete.block',
-          at: focusTextBlock.path,
-        }),
-        raise({
-          type: 'select',
-          at: {
-            anchor: previousBlockEndPoint,
-            focus: previousBlockEndPoint,
-          },
-        }),
-        raise({
-          type: 'insert.block',
-          block: focusTextBlock.node,
-          placement: 'auto',
-          select: 'start',
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'delete.forward',
-    guard: ({snapshot}) => {
-      return snapshot.context.selection
-    },
-    actions: [
-      ({event}) => [
-        raise({
-          type: 'delete',
-          direction: 'forward',
-          unit: event.unit,
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'delete',
-    guard: ({snapshot, event}) => {
-      if (event.direction !== 'forward') {
-        return false
-      }
-
-      const at = event.at ?? snapshot.context.selection
-
-      if (!at) {
-        return false
-      }
-
-      const nextBlock = getNextBlock({
-        ...snapshot,
-        context: {
-          ...snapshot.context,
-          selection: at,
-        },
-      })
-      const focusTextBlock = getFocusTextBlock({
-        ...snapshot,
-        context: {
-          ...snapshot.context,
-          selection: at,
-        },
-      })
-
-      if (!nextBlock || !focusTextBlock) {
-        return false
-      }
-
-      if (!isEmptyTextBlock(snapshot.context, focusTextBlock.node)) {
-        return false
-      }
-
-      const nextBlockStartPoint = getBlockStartPoint({
-        context: snapshot.context,
-        block: nextBlock,
-      })
-
-      return {focusTextBlock, nextBlockStartPoint}
-    },
-    actions: [
-      (_, {focusTextBlock, nextBlockStartPoint}) => [
-        raise({
-          type: 'delete.block',
-          at: focusTextBlock.path,
-        }),
-        raise({
-          type: 'select',
-          at: {
-            anchor: nextBlockStartPoint,
-            focus: nextBlockStartPoint,
-          },
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'delete',
-    guard: ({snapshot, event}) => {
-      if (event.direction !== 'forward') {
-        return false
-      }
-
-      const nextBlock = getNextBlock(snapshot)
-      const focusTextBlock = getFocusTextBlock(snapshot)
-
-      if (!nextBlock || !focusTextBlock) {
-        return false
-      }
-
-      if (!isAtTheEndOfBlock(focusTextBlock)(snapshot)) {
-        return false
-      }
-
-      if (!isTextBlock(snapshot.context, nextBlock.node)) {
-        return false
-      }
-
-      return {nextBlock}
-    },
-    actions: [
-      (_, {nextBlock}) => [
-        raise({
-          type: 'delete.block',
-          at: nextBlock.path,
-        }),
-        raise({
-          type: 'insert.block',
-          block: nextBlock.node,
-          placement: 'auto',
-          select: 'none',
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'delete.block',
-    actions: [
-      ({event}) => [
-        raise({
-          type: 'delete',
-          at: {
-            anchor: {
-              path: event.at,
-              offset: 0,
-            },
-            focus: {
-              path: event.at,
-              offset: 0,
-            },
-          },
-          unit: 'block',
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'delete.child',
-    guard: ({snapshot, event}) => {
-      const focusChild = getFocusChild({
-        ...snapshot,
-        context: {
-          ...snapshot.context,
-          selection: {
-            anchor: {
-              path: event.at,
-              offset: 0,
-            },
-            focus: {
-              path: event.at,
-              offset: 0,
-            },
-          },
-        },
-      })
-
-      if (!focusChild) {
-        return false
-      }
-
-      if (isSpan(snapshot.context, focusChild.node)) {
-        return {
-          selection: {
-            anchor: {
-              path: event.at,
-              offset: 0,
-            },
-            focus: {
-              path: event.at,
-              offset: focusChild.node.text.length,
-            },
-          },
-        }
-      }
-
-      return {
-        selection: {
-          anchor: {
-            path: event.at,
-            offset: 0,
-          },
-          focus: {
-            path: event.at,
-            offset: 0,
-          },
-        },
-      }
-    },
-    actions: [(_, {selection}) => [raise({type: 'delete', at: selection})]],
-  }),
-  defineBehavior({
-    on: 'delete.text',
-    actions: [({event}) => [raise({...event, type: 'delete'})]],
-  }),
-]

package/src/behaviors/behavior.abstract.deserialize.ts

@@ -1,232 +0,0 @@
-import {isTextBlock} from '@portabletext/schema'
-import type {MIMEType} from '../internal-utils/mime-type'
-import {getActiveAnnotations} from '../selectors/selector.get-active-annotations'
-import {getActiveDecorators} from '../selectors/selector.get-active-decorators'
-import {getFocusTextBlock} from '../selectors/selector.get-focus-text-block'
-import {getTextBlockText} from '../utils/util.get-text-block-text'
-import {raise} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-const mimeTypePriority: Array<MIMEType> = [
-  'application/x-portable-text',
-  'application/json',
-  'text/markdown',
-  'text/html',
-  'text/plain',
-]
-
-/**
- * Finds the first available data from the dataTransfer based on priority.
- * Optionally starts from a specific mime type in the priority list.
- */
-function getFirstAvailableData({
-  dataTransfer,
-  startAfter,
-}: {
-  dataTransfer: DataTransfer
-  startAfter?: MIMEType
-}): {mimeType: MIMEType; data: string} | undefined {
-  const startIndex = startAfter ? mimeTypePriority.indexOf(startAfter) + 1 : 0
-
-  for (let index = startIndex; index < mimeTypePriority.length; index++) {
-    const mimeType = mimeTypePriority.at(index)
-
-    if (!mimeType) {
-      continue
-    }
-
-    const data = dataTransfer.getData(mimeType)
-
-    if (!data) {
-      continue
-    }
-
-    return {
-      mimeType,
-      data,
-    }
-  }
-
-  return undefined
-}
-
-export const abstractDeserializeBehaviors = [
-  defineBehavior({
-    on: 'deserialize',
-    guard: ({event}) => {
-      const availableData = getFirstAvailableData({
-        dataTransfer: event.originEvent.originEvent.dataTransfer,
-      })
-
-      if (!availableData) {
-        return false
-      }
-
-      return {
-        type: 'deserialize.data' as const,
-        mimeType: availableData.mimeType,
-        data: availableData.data,
-        originEvent: event.originEvent,
-      }
-    },
-    actions: [(_, deserializeEvent) => [raise(deserializeEvent)]],
-  }),
-  defineBehavior({
-    on: 'deserialize',
-    actions: [
-      ({event}) => [
-        raise({
-          type: 'deserialization.failure',
-          mimeType: '*/*',
-          reason: 'No Behavior was able to handle the incoming data',
-          originEvent: event.originEvent,
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'deserialize.data',
-    guard: ({snapshot, event}) => {
-      const converter = snapshot.context.converters.find(
-        (converter) => converter.mimeType === event.mimeType,
-      )
-
-      if (!converter) {
-        return false
-      }
-
-      return converter.deserialize({
-        snapshot,
-        event: {
-          type: 'deserialize',
-          data: event.data,
-        },
-      })
-    },
-    actions: [
-      ({event}, deserializeEvent) => [
-        raise({
-          ...deserializeEvent,
-          originEvent: event.originEvent,
-        }),
-      ],
-    ],
-  }),
-  /**
-   * If we are pasting text/plain into a text block then we can probably
-   * assume that the intended behavior is that the pasted text inherits
-   * formatting from the text it's pasted into.
-   */
-  defineBehavior({
-    on: 'deserialization.success',
-    guard: ({snapshot, event}) => {
-      const focusTextBlock = getFocusTextBlock(snapshot)
-
-      if (
-        focusTextBlock &&
-        event.mimeType === 'text/plain' &&
-        event.originEvent.type === 'clipboard.paste'
-      ) {
-        const activeDecorators = getActiveDecorators(snapshot)
-        const activeAnnotations = getActiveAnnotations(snapshot)
-
-        return {
-          activeAnnotations,
-          activeDecorators,
-          textRuns: event.data.flatMap((block) =>
-            isTextBlock(snapshot.context, block)
-              ? [getTextBlockText(block)]
-              : [],
-          ),
-        }
-      }
-
-      return false
-    },
-    actions: [
-      (_, {activeAnnotations, activeDecorators, textRuns}) =>
-        textRuns.flatMap((textRun, index) =>
-          index !== textRuns.length - 1
-            ? [
-                raise({
-                  type: 'insert.span',
-                  text: textRun,
-                  decorators: activeDecorators,
-                  annotations: activeAnnotations.map(
-                    ({_key, _type, ...value}) => ({
-                      name: _type,
-                      value,
-                    }),
-                  ),
-                }),
-                raise({type: 'insert.break'}),
-              ]
-            : [
-                raise({
-                  type: 'insert.span',
-                  text: textRun,
-                  decorators: activeDecorators,
-                  annotations: activeAnnotations.map(
-                    ({_key, _type, ...value}) => ({
-                      name: _type,
-                      value,
-                    }),
-                  ),
-                }),
-              ],
-        ),
-    ],
-  }),
-  defineBehavior({
-    on: 'deserialization.success',
-    actions: [
-      ({event}) => [
-        raise({
-          type: 'insert.blocks',
-          blocks: event.data,
-          placement: 'auto',
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'deserialization.failure',
-    guard: ({event}) => {
-      if (event.mimeType === '*/*') {
-        return false
-      }
-
-      const availableData = getFirstAvailableData({
-        dataTransfer: event.originEvent.originEvent.dataTransfer,
-        startAfter: event.mimeType,
-      })
-
-      if (!availableData) {
-        return false
-      }
-
-      return {
-        type: 'deserialize.data' as const,
-        mimeType: availableData.mimeType,
-        data: availableData.data,
-        originEvent: event.originEvent,
-      }
-    },
-    actions: [(_, deserializeDataEvent) => [raise(deserializeDataEvent)]],
-  }),
-  defineBehavior({
-    on: 'deserialization.failure',
-    actions: [
-      ({event}) => [
-        {
-          type: 'effect',
-          effect: () => {
-            console.warn(
-              `Deserialization of ${event.mimeType} failed with reason "${event.reason}"`,
-            )
-          },
-        },
-      ],
-    ],
-  }),
-]