@portabletext/editor 1.16.2 → 1.16.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "1.16.2",
+  "version": "1.16.4",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -61,7 +61,7 @@
     "get-random-values-esm": "^1.0.2",
     "lodash": "^4.17.21",
     "lodash.startcase": "^4.4.0",
-    "react-compiler-runtime": "19.0.0-beta-37ed2a7-20241206",
+    "react-compiler-runtime": "19.0.0-beta-201e55d-20241215",
     "slate": "0.112.0",
     "slate-dom": "^0.111.0",
     "slate-react": "0.112.0",
@@ -87,9 +87,9 @@
     "@vitejs/plugin-react": "^4.3.4",
     "@vitest/browser": "^2.1.8",
     "@vitest/coverage-istanbul": "^2.1.8",
-    "babel-plugin-react-compiler": "19.0.0-beta-37ed2a7-20241206",
+    "babel-plugin-react-compiler": "19.0.0-beta-201e55d-20241215",
     "eslint": "8.57.1",
-    "eslint-plugin-react-compiler": "19.0.0-beta-37ed2a7-20241206",
+    "eslint-plugin-react-compiler": "19.0.0-beta-201e55d-20241215",
     "eslint-plugin-react-hooks": "^5.1.0",
     "jsdom": "^25.0.1",
     "react": "^19.0.0",

package/src/behavior-actions/behavior.actions.ts

@@ -23,7 +23,6 @@ import {
 } from '../editor/plugins/createWithPortableTextMarkModel'
 import {blockOffsetToSpanSelectionPoint} from '../editor/utils/utils.block-offset'
 import type {PickFromUnion} from '../type-utils'
-import debug from '../utils/debug'
 import {toSlatePath} from '../utils/paths'
 import {toSlateRange} from '../utils/ranges'
 import {fromSlateValue, toSlateValue} from '../utils/values'
@@ -283,8 +282,6 @@ export function performAction({
   context: BehaviorActionImplementationContext
   action: BehaviorAction
 }) {
-  debug('Behavior action', action)
-
   switch (action.type) {
     case 'delete.block': {
       behaviorActionImplementations['delete.block']({

package/src/editor/create-editor.ts

@@ -56,6 +56,8 @@ export type EditorConfig = {
 export type EditorEvent = PickFromUnion<
   InternalEditorEvent,
   'type',
+  | 'annotation.add'
+  | 'annotation.remove'
   | 'annotation.toggle'
   | 'blur'
   | 'decorator.add'

package/src/editor/editor-machine.ts

@@ -25,7 +25,6 @@ import type {
   InvalidValueResolution,
   PortableTextSlateEditor,
 } from '../types/editor'
-import debug from '../utils/debug'
 import {toPortableTextRange} from '../utils/ranges'
 import {fromSlateValue} from '../utils/values'
 import {KEY_TO_VALUE_ELEMENT} from '../utils/weakMaps'
@@ -69,7 +68,7 @@ export type MutationEvent = {
 export type InternalEditorEvent =
   | {type: 'normalizing'}
   | {type: 'done normalizing'}
-  | {type: 'done syncing'}
+  | {type: 'done syncing initial value'}
   | {
       type: 'behavior event'
       behaviorEvent: SyntheticBehaviorEvent | NativeBehaviorEvent
@@ -101,7 +100,11 @@ export type InternalEditorEvent =
       type: 'update maxBlocks'
       maxBlocks: number | undefined
     }
-  | OmitFromUnion<InternalEditorEmittedEvent, 'type', 'read only' | 'editable'>
+  | OmitFromUnion<
+      InternalEditorEmittedEvent,
+      'type',
+      'ready' | 'read only' | 'editable'
+    >
 
 /**
  * @alpha
@@ -242,8 +245,6 @@ export const editorMachine = setup({
     'handle behavior event': enqueueActions(({context, event, enqueue}) => {
       assertEvent(event, ['behavior event'])
 
-      debug('Behavior event', event)
-
       const defaultAction =
         event.behaviorEvent.type === 'copy' ||
         event.behaviorEvent.type === 'key.down' ||
@@ -427,7 +428,7 @@ export const editorMachine = setup({
           states: {
             'determine initial edit mode': {
               on: {
-                'done syncing': [
+                'done syncing initial value': [
                   {
                     target: '#editor.edit mode.read only.read only',
                     guard: ({context}) => context.initialReadOnly,
@@ -502,7 +503,7 @@ export const editorMachine = setup({
             'mutation': {
               actions: 'defer event',
             },
-            'done syncing': {
+            'done syncing initial value': {
               target: 'pristine',
             },
           },

package/src/editor/sync-machine.ts

@@ -3,13 +3,10 @@ import type {PortableTextBlock} from '@sanity/types'
 import {isEqual} from 'lodash'
 import {Editor, Text, Transforms, type Descendant, type Node} from 'slate'
 import {
-  and,
   assertEvent,
   assign,
   emit,
   fromCallback,
-  not,
-  or,
   setup,
   type AnyEventObject,
   type CallbackLogicFunction,
@@ -118,11 +115,13 @@ export const syncMachine = setup({
           readOnly: boolean
         }
       | SyncValueEvent,
-    emitted: {} as PickFromUnion<
-      SyncValueEvent,
-      'type',
-      'done syncing' | 'invalid value' | 'patch' | 'value changed'
-    >,
+    emitted: {} as
+      | PickFromUnion<
+          SyncValueEvent,
+          'type',
+          'invalid value' | 'patch' | 'value changed'
+        >
+      | {type: 'done syncing initial value'},
   },
   actions: {
     'assign initial value synced': assign({
@@ -149,21 +148,19 @@ export const syncMachine = setup({
         return event.value
       },
     }),
-    'emit done syncing': emit(({event}) => {
-      assertEvent(event, 'done syncing')
-      return event
+    'emit done syncing initial value': emit({
+      type: 'done syncing initial value',
     }),
   },
   guards: {
-    'is readOnly': ({context}) => context.readOnly,
-    'is processing local changes': ({context}) =>
-      context.isProcessingLocalChanges,
-    'is processing remote changes': ({context}) =>
-      isChangingRemotely(context.slateEditor) ?? false,
-    'is busy': and([
-      not('is readOnly'),
-      or(['is processing local changes', 'is processing remote changes']),
-    ]),
+    'initial value synced': ({context}) => context.initialValueSynced,
+    'is busy': ({context}) => {
+      return (
+        !context.readOnly &&
+        (context.isProcessingLocalChanges ||
+          (isChangingRemotely(context.slateEditor) ?? false))
+      )
+    },
     'value changed while syncing': ({context, event}) => {
       assertEvent(event, 'done syncing')
       return context.pendingValue !== event.value
@@ -189,7 +186,6 @@ export const syncMachine = setup({
     pendingValue: undefined,
     previousValue: undefined,
   }),
-  initial: 'idle',
   on: {
     'has pending patches': {
       actions: assign({
@@ -205,103 +201,117 @@ export const syncMachine = setup({
       actions: ['assign readOnly'],
     },
   },
+  type: 'parallel',
   states: {
-    idle: {
-      on: {
-        'update value': [
-          {
-            guard: 'is busy',
-            target: 'busy',
-            actions: ['assign pending value'],
-          },
-          {
-            target: 'syncing',
-            actions: ['assign pending value'],
+    'setting up': {
+      initial: 'syncing initial value',
+      states: {
+        'syncing initial value': {
+          always: {
+            guard: 'initial value synced',
+            target: 'done syncing initial value',
           },
-        ],
-      },
-    },
-    busy: {
-      after: {
-        1000: {
-          target: 'syncing',
         },
-      },
-      on: {
-        'update value': [
-          {
-            guard: 'is busy',
-            actions: ['assign pending value'],
-            reenter: true,
-          },
-          {
-            target: 'syncing',
-            actions: ['assign pending value'],
-          },
-        ],
-      },
-    },
-    syncing: {
-      invoke: {
-        src: 'sync value',
-        id: 'sync value',
-        input: ({context}) => {
-          return {
-            context: {
-              keyGenerator: context.keyGenerator,
-              previousValue: context.previousValue,
-              readOnly: context.readOnly,
-              schema: context.schema,
-            },
-            slateEditor: context.slateEditor,
-            streamBlocks: !context.initialValueSynced,
-            value: context.pendingValue ?? undefined,
-          }
+        'done syncing initial value': {
+          entry: ['emit done syncing initial value'],
+          type: 'final',
         },
       },
-      always: {
-        guard: 'pending value equals previous value',
-        actions: [
-          emit(({context}) => ({
-            type: 'done syncing',
-            value: context.previousValue,
-          })),
-        ],
-        target: 'idle',
-      },
-      on: {
-        'update value': {
-          actions: ['assign pending value'],
-        },
-        'patch': {
-          actions: [emit(({event}) => event)],
-        },
-        'invalid value': {
-          actions: [emit(({event}) => event)],
-        },
-        'value changed': {
-          actions: [emit(({event}) => event)],
+    },
+    'syncing': {
+      initial: 'idle',
+      states: {
+        idle: {
+          on: {
+            'update value': [
+              {
+                guard: 'is busy',
+                target: 'busy',
+                actions: ['assign pending value'],
+              },
+              {
+                target: 'syncing',
+                actions: ['assign pending value'],
+              },
+            ],
+          },
         },
-        'done syncing': [
-          {
-            guard: 'value changed while syncing',
-            actions: [
-              'assign previous value',
-              'emit done syncing',
-              'assign initial value synced',
+        busy: {
+          after: {
+            1000: [
+              {
+                guard: 'is busy',
+                reenter: true,
+              },
+              {
+                target: 'syncing',
+              },
+            ],
+          },
+          on: {
+            'update value': [
+              {
+                actions: ['assign pending value'],
+              },
             ],
-            reenter: true,
           },
-          {
+        },
+        syncing: {
+          always: {
+            guard: 'pending value equals previous value',
             target: 'idle',
-            actions: [
-              'clear pending value',
-              'assign previous value',
-              'emit done syncing',
-              'assign initial value synced',
+            actions: ['clear pending value', 'assign initial value synced'],
+          },
+          invoke: {
+            src: 'sync value',
+            id: 'sync value',
+            input: ({context}) => {
+              return {
+                context: {
+                  keyGenerator: context.keyGenerator,
+                  previousValue: context.previousValue,
+                  readOnly: context.readOnly,
+                  schema: context.schema,
+                },
+                slateEditor: context.slateEditor,
+                streamBlocks: !context.initialValueSynced,
+                value: context.pendingValue,
+              }
+            },
+          },
+          on: {
+            'update value': {
+              actions: ['assign pending value'],
+            },
+            'patch': {
+              actions: [emit(({event}) => event)],
+            },
+            'invalid value': {
+              actions: [emit(({event}) => event)],
+            },
+            'value changed': {
+              actions: [emit(({event}) => event)],
+            },
+            'done syncing': [
+              {
+                guard: 'value changed while syncing',
+                actions: [
+                  'assign previous value',
+                  'assign initial value synced',
+                ],
+                reenter: true,
+              },
+              {
+                target: 'idle',
+                actions: [
+                  'clear pending value',
+                  'assign previous value',
+                  'assign initial value synced',
+                ],
+              },
             ],
           },
-        ],
+        },
       },
     },
   },