@portabletext/editor 1.31.2 → 1.32.0

package/src/editor/plugins/createWithUndoRedo.ts

@@ -20,6 +20,7 @@ import {
   type Descendant,
   type SelectionOperation,
 } from 'slate'
+import type {BehaviorActionImplementation} from '../../behavior-actions/behavior.actions'
 import {debugWithName} from '../../internal-utils/debug'
 import {fromSlateValue} from '../../internal-utils/values'
 import {isChangingRemotely} from '../../internal-utils/withChanges'
@@ -33,6 +34,7 @@ import {
 } from '../../internal-utils/withUndoRedo'
 import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
+import {getCurrentBehaviorActionSetId} from '../with-applying-behavior-actions'
 
 const debug = debugWithName('plugin:withUndoRedo')
 const debugVerbose = debug.enabled && false
@@ -78,6 +80,8 @@ export function createWithUndoRedo(
       blockSchemaType.name,
     )
     const remotePatches = getRemotePatches(editor)
+    let previousBehaviorActionIntendSetId =
+      getCurrentBehaviorActionSetId(editor)
 
     options.subscriptions.push(() => {
       debug('Subscribing to patches')
@@ -112,7 +116,9 @@ export function createWithUndoRedo(
     })
 
     editor.history = {undos: [], redos: []}
+
     const {apply} = editor
+
     editor.apply = (op: Operation) => {
       if (editorActor.getSnapshot().matches({'edit mode': 'read only'})) {
         apply(op)
@@ -145,12 +151,28 @@ export function createWithUndoRedo(
       const overwrite = shouldOverwrite(op, lastOp)
       const save = isSaving(editor)
 
-      let merge = true
+      const currentBehaviorActionIntendSetId =
+        getCurrentBehaviorActionSetId(editor)
+
+      let merge =
+        currentBehaviorActionIntendSetId !== undefined &&
+        previousBehaviorActionIntendSetId === undefined
+          ? false
+          : currentBehaviorActionIntendSetId !== undefined &&
+              previousBehaviorActionIntendSetId !== undefined
+            ? currentBehaviorActionIntendSetId ===
+              previousBehaviorActionIntendSetId
+            : true
+
       if (save) {
         if (!step) {
           merge = false
         } else if (operations.length === 0) {
-          merge = shouldMerge(op, lastOp) || overwrite
+          merge =
+            currentBehaviorActionIntendSetId === undefined &&
+            previousBehaviorActionIntendSetId === undefined
+              ? shouldMerge(op, lastOp) || overwrite
+              : merge
         }
 
         if (step && merge) {
@@ -177,123 +199,126 @@ export function createWithUndoRedo(
           history.redos = []
         }
       }
+
+      previousBehaviorActionIntendSetId = currentBehaviorActionIntendSetId
+
       apply(op)
     }
 
-    editor.undo = () => {
-      if (editorActor.getSnapshot().matches({'edit mode': 'read only'})) {
-        return
-      }
-      const {undos} = editor.history
-      if (undos.length > 0) {
-        const step = undos[undos.length - 1]
-        debug('Undoing', step)
-        if (step.operations.length > 0) {
-          const otherPatches = remotePatches.filter(
-            (item) => item.time >= step.timestamp,
-          )
-          let transformedOperations = step.operations
-          otherPatches.forEach((item) => {
-            transformedOperations = flatten(
-              transformedOperations.map((op) =>
-                transformOperation(
-                  editor,
-                  item.patch,
-                  op,
-                  item.snapshot,
-                  item.previousSnapshot,
-                ),
-              ),
-            )
-          })
-          const reversedOperations = transformedOperations
-            .map(Operation.inverse)
-            .reverse()
-
-          try {
-            Editor.withoutNormalizing(editor, () => {
-              withUndoing(editor, () => {
-                withoutSaving(editor, () => {
-                  reversedOperations.forEach((op) => {
-                    editor.apply(op)
-                  })
-                })
+    // Plugin return
+    return editor
+  }
+}
+
+export const historyUndoActionImplementation: BehaviorActionImplementation<
+  'history.undo'
+> = ({action}) => {
+  const editor = action.editor
+  const {undos} = editor.history
+  const remotePatches = getRemotePatches(editor)
+
+  if (undos.length > 0) {
+    const step = undos[undos.length - 1]
+    debug('Undoing', step)
+    if (step.operations.length > 0) {
+      const otherPatches = remotePatches.filter(
+        (item) => item.time >= step.timestamp,
+      )
+      let transformedOperations = step.operations
+      otherPatches.forEach((item) => {
+        transformedOperations = flatten(
+          transformedOperations.map((op) =>
+            transformOperation(
+              editor,
+              item.patch,
+              op,
+              item.snapshot,
+              item.previousSnapshot,
+            ),
+          ),
+        )
+      })
+      const reversedOperations = transformedOperations
+        .map(Operation.inverse)
+        .reverse()
+
+      try {
+        Editor.withoutNormalizing(editor, () => {
+          withUndoing(editor, () => {
+            withoutSaving(editor, () => {
+              reversedOperations.forEach((op) => {
+                editor.apply(op)
               })
             })
-            editor.normalize()
-            editor.onChange()
-          } catch (err) {
-            debug('Could not perform undo step', err)
-            remotePatches.splice(0, remotePatches.length)
-            Transforms.deselect(editor)
-            editor.history = {undos: [], redos: []}
-            SAVING.set(editor, true)
-            setIsUndoing(editor, false)
-            editor.onChange()
-            return
-          }
-          editor.history.redos.push(step)
-          editor.history.undos.pop()
-        }
+          })
+        })
+      } catch (err) {
+        debug('Could not perform undo step', err)
+        remotePatches.splice(0, remotePatches.length)
+        Transforms.deselect(editor)
+        editor.history = {undos: [], redos: []}
+        SAVING.set(editor, true)
+        setIsUndoing(editor, false)
+        editor.onChange()
+        return
       }
+      editor.history.redos.push(step)
+      editor.history.undos.pop()
     }
+  }
+}
 
-    editor.redo = () => {
-      if (editorActor.getSnapshot().matches({'edit mode': 'read only'})) {
-        return
-      }
-      const {redos} = editor.history
-      if (redos.length > 0) {
-        const step = redos[redos.length - 1]
-        debug('Redoing', step)
-        if (step.operations.length > 0) {
-          const otherPatches = remotePatches.filter(
-            (item) => item.time >= step.timestamp,
-          )
-          let transformedOperations = step.operations
-          otherPatches.forEach((item) => {
-            transformedOperations = flatten(
-              transformedOperations.map((op) =>
-                transformOperation(
-                  editor,
-                  item.patch,
-                  op,
-                  item.snapshot,
-                  item.previousSnapshot,
-                ),
-              ),
-            )
-          })
-          try {
-            Editor.withoutNormalizing(editor, () => {
-              withRedoing(editor, () => {
-                withoutSaving(editor, () => {
-                  transformedOperations.forEach((op) => {
-                    editor.apply(op)
-                  })
-                })
+export const historyRedoActionImplementation: BehaviorActionImplementation<
+  'history.redo'
+> = ({action}) => {
+  const editor = action.editor
+  const {redos} = editor.history
+  const remotePatches = getRemotePatches(editor)
+
+  if (redos.length > 0) {
+    const step = redos[redos.length - 1]
+    debug('Redoing', step)
+    if (step.operations.length > 0) {
+      const otherPatches = remotePatches.filter(
+        (item) => item.time >= step.timestamp,
+      )
+      let transformedOperations = step.operations
+      otherPatches.forEach((item) => {
+        transformedOperations = flatten(
+          transformedOperations.map((op) =>
+            transformOperation(
+              editor,
+              item.patch,
+              op,
+              item.snapshot,
+              item.previousSnapshot,
+            ),
+          ),
+        )
+      })
+      try {
+        Editor.withoutNormalizing(editor, () => {
+          withRedoing(editor, () => {
+            withoutSaving(editor, () => {
+              transformedOperations.forEach((op) => {
+                editor.apply(op)
               })
             })
-            editor.normalize()
-            editor.onChange()
-          } catch (err) {
-            debug('Could not perform redo step', err)
-            remotePatches.splice(0, remotePatches.length)
-            Transforms.deselect(editor)
-            editor.history = {undos: [], redos: []}
-            SAVING.set(editor, true)
-            setIsRedoing(editor, false)
-            editor.onChange()
-            return
-          }
-          editor.history.undos.push(step)
-          editor.history.redos.pop()
-        }
+          })
+        })
+      } catch (err) {
+        debug('Could not perform redo step', err)
+        remotePatches.splice(0, remotePatches.length)
+        Transforms.deselect(editor)
+        editor.history = {undos: [], redos: []}
+        SAVING.set(editor, true)
+        setIsRedoing(editor, false)
+        editor.onChange()
+        return
       }
+      editor.history.undos.push(step)
+      editor.history.redos.pop()
     }
-
-    // Plugin return
-    return editor
   }
 }
 

package/src/editor/with-applying-behavior-actions.ts

@@ -1,15 +1,39 @@
-import type {Editor} from 'slate'
+import {Editor} from 'slate'
+import {defaultKeyGenerator} from './key-generator'
 
 const IS_APPLYING_BEHAVIOR_ACTIONS: WeakMap<Editor, boolean | undefined> =
   new WeakMap()
 
 export function withApplyingBehaviorActions(editor: Editor, fn: () => void) {
-  const prev = isApplyingBehaviorActions(editor)
+  const prev = IS_APPLYING_BEHAVIOR_ACTIONS.get(editor)
   IS_APPLYING_BEHAVIOR_ACTIONS.set(editor, true)
-  fn()
+  Editor.withoutNormalizing(editor, fn)
   IS_APPLYING_BEHAVIOR_ACTIONS.set(editor, prev)
 }
 
 export function isApplyingBehaviorActions(editor: Editor) {
   return IS_APPLYING_BEHAVIOR_ACTIONS.get(editor) ?? false
 }
+
+////////
+
+const CURRENT_BEHAVIOR_ACTION_INTEND_SET: WeakMap<
+  Editor,
+  {actionSetId: string} | undefined
+> = new WeakMap()
+
+export function withApplyingBehaviorActionIntendSet(
+  editor: Editor,
+  fn: () => void,
+) {
+  const current = CURRENT_BEHAVIOR_ACTION_INTEND_SET.get(editor)
+  CURRENT_BEHAVIOR_ACTION_INTEND_SET.set(editor, {
+    actionSetId: defaultKeyGenerator(),
+  })
+  withApplyingBehaviorActions(editor, fn)
+  CURRENT_BEHAVIOR_ACTION_INTEND_SET.set(editor, current)
+}
+
+export function getCurrentBehaviorActionSetId(editor: Editor) {
+  return CURRENT_BEHAVIOR_ACTION_INTEND_SET.get(editor)?.actionSetId
+}