@portabletext/editor 3.3.3 → 3.3.4

package/src/editor/plugins/createWithObjectKeys.ts

@@ -1,289 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import {isEqual} from 'lodash'
-import {Editor, Element, Node, Path, Transforms} from 'slate'
-import {isRedoing} from '../../history/slate-plugin.redoing'
-import {isUndoing} from '../../history/slate-plugin.undoing'
-import type {PortableTextSlateEditor} from '../../types/slate-editor'
-import type {EditorActor} from '../editor-machine'
-import {withNormalizeNode} from '../with-normalizing-node'
-import {isChangingRemotely} from '../withChanges'
-
-/**
- * This plugin makes sure that every new node in the editor get a new _key prop when created
- *
- */
-export function createWithObjectKeys(editorActor: EditorActor) {
-  return function withKeys(
-    editor: PortableTextSlateEditor,
-  ): PortableTextSlateEditor {
-    const {apply, normalizeNode} = editor
-
-    // The default behavior is to always generate a new key here.
-    // For example, when undoing and redoing we want to retain the keys, but
-    // when we create a new bold span by splitting a non-bold-span we want the produced node to get a new key.
-    editor.apply = (operation) => {
-      /**
-       * We don't want to run any side effects when the editor is processing
-       * remote changes.
-       */
-      if (isChangingRemotely(editor)) {
-        apply(operation)
-        return
-      }
-
-      /**
-       * We don't want to run any side effects when the editor is undoing or
-       * redoing operations.
-       */
-      if (isUndoing(editor) || isRedoing(editor)) {
-        apply(operation)
-        return
-      }
-
-      if (operation.type === 'split_node') {
-        const existingKeys = [...Node.descendants(editor)].map(
-          ([node]) => node._key,
-        )
-
-        apply({
-          ...operation,
-          properties: {
-            ...operation.properties,
-            _key:
-              operation.properties._key === undefined ||
-              existingKeys.includes(operation.properties._key)
-                ? editorActor.getSnapshot().context.keyGenerator()
-                : operation.properties._key,
-          },
-        })
-
-        return
-      }
-
-      if (operation.type === 'insert_node') {
-        if (!Editor.isEditor(operation.node)) {
-          const existingKeys = [...Node.descendants(editor)].map(
-            ([node]) => node._key,
-          )
-
-          apply({
-            ...operation,
-            node: {
-              ...operation.node,
-              _key:
-                operation.node._key === undefined ||
-                existingKeys.includes(operation.node._key)
-                  ? editorActor.getSnapshot().context.keyGenerator()
-                  : operation.node._key,
-            },
-          })
-
-          return
-        }
-      }
-
-      if (operation.type === 'merge_node') {
-        const index = operation.path[operation.path.length - 1]
-        const prevPath = Path.previous(operation.path)
-        const prevIndex = prevPath[prevPath.length - 1]
-
-        if (operation.path.length !== 1 || prevPath.length !== 1) {
-          apply(operation)
-          return
-        }
-
-        const block = editor.value.at(index)
-        const previousBlock = editor.value.at(prevIndex)
-
-        if (!block || !previousBlock) {
-          apply(operation)
-          return
-        }
-
-        if (
-          !isTextBlock(editorActor.getSnapshot().context, block) ||
-          !isTextBlock(editorActor.getSnapshot().context, previousBlock)
-        ) {
-          apply(operation)
-          return
-        }
-
-        // If we are merging two text blocks, then we need to make sure there
-        // are no duplicate keys in the blocks. Therefore, we assign new keys
-        // to any child or markDef that shares key with other children or
-        // markDefs in the previous block.
-        const previousBlockChildKeys = previousBlock.children.map(
-          (child) => child._key,
-        )
-        const previousBlockMarkDefKeys =
-          previousBlock.markDefs?.map((markDef) => markDef._key) ?? []
-
-        // Assign new keys to markDefs with duplicate keys and keep track of
-        // the mapping between the old and new keys
-        const markDefKeyMap = new Map<string, string>()
-        const adjustedMarkDefs = block.markDefs?.map((markDef) => {
-          if (previousBlockMarkDefKeys.includes(markDef._key)) {
-            const newKey = editorActor.getSnapshot().context.keyGenerator()
-            markDefKeyMap.set(markDef._key, newKey)
-            return {
-              ...markDef,
-              _key: newKey,
-            }
-          }
-
-          return markDef
-        })
-
-        // Assign new keys to spans with duplicate keys and update any markDef
-        // key if needed
-        let childIndex = 0
-        for (const child of block.children) {
-          if (isSpan(editorActor.getSnapshot().context, child)) {
-            const marks =
-              child.marks?.map((mark) => {
-                const markDefKey = markDefKeyMap.get(mark)
-
-                if (markDefKey) {
-                  return markDefKey
-                }
-
-                return mark
-              }) ?? []
-
-            if (!isEqual(child.marks, marks)) {
-              Transforms.setNodes(
-                editor,
-                {
-                  marks,
-                },
-                {
-                  at: [index, childIndex],
-                },
-              )
-            }
-          }
-
-          if (previousBlockChildKeys.includes(child._key)) {
-            Transforms.setNodes(
-              editor,
-              {
-                _key: editorActor.getSnapshot().context.keyGenerator(),
-              },
-              {
-                at: [index, childIndex],
-              },
-            )
-          }
-          childIndex++
-        }
-
-        apply({
-          ...operation,
-          properties: {
-            ...operation.properties,
-            // Make sure the adjusted markDefs are carried along for the merge
-            // operation
-            markDefs: adjustedMarkDefs,
-          },
-        })
-        return
-      }
-
-      apply(operation)
-    }
-
-    editor.normalizeNode = (entry) => {
-      const [node, path] = entry
-
-      if (Element.isElement(node)) {
-        const [parent] = Editor.parent(editor, path)
-
-        if (parent && Editor.isEditor(parent)) {
-          const blockKeys = new Set<string>()
-
-          for (const sibling of parent.children) {
-            if (sibling._key && blockKeys.has(sibling._key)) {
-              const _key = editorActor.getSnapshot().context.keyGenerator()
-
-              blockKeys.add(_key)
-
-              withNormalizeNode(editor, () => {
-                Transforms.setNodes(editor, {_key}, {at: path})
-              })
-
-              return
-            }
-
-            if (!sibling._key) {
-              const _key = editorActor.getSnapshot().context.keyGenerator()
-
-              blockKeys.add(_key)
-
-              withNormalizeNode(editor, () => {
-                Transforms.setNodes(editor, {_key}, {at: path})
-              })
-
-              return
-            }
-
-            blockKeys.add(sibling._key)
-          }
-        }
-      }
-
-      if (
-        Element.isElement(node) &&
-        node._type === editorActor.getSnapshot().context.schema.block.name
-      ) {
-        // Set key on block itself
-        if (!node._key) {
-          withNormalizeNode(editor, () => {
-            Transforms.setNodes(
-              editor,
-              {_key: editorActor.getSnapshot().context.keyGenerator()},
-              {at: path},
-            )
-          })
-          return
-        }
-
-        // Set unique keys on it's children
-        const childKeys = new Set<string>()
-
-        for (const [child, childPath] of Node.children(editor, path)) {
-          if (child._key && childKeys.has(child._key)) {
-            const _key = editorActor.getSnapshot().context.keyGenerator()
-
-            childKeys.add(_key)
-
-            withNormalizeNode(editor, () => {
-              Transforms.setNodes(editor, {_key}, {at: childPath})
-            })
-
-            return
-          }
-
-          if (!child._key) {
-            const _key = editorActor.getSnapshot().context.keyGenerator()
-
-            childKeys.add(_key)
-
-            withNormalizeNode(editor, () => {
-              Transforms.setNodes(editor, {_key}, {at: childPath})
-            })
-
-            return
-          }
-
-          childKeys.add(child._key)
-        }
-      }
-
-      withNormalizeNode(editor, () => {
-        normalizeNode(entry)
-      })
-    }
-
-    return editor
-  }
-}

package/src/editor/plugins/createWithPatches.ts

@@ -1,272 +0,0 @@
-import {insert, setIfMissing, unset, type Patch} from '@portabletext/patches'
-import type {PortableTextBlock} from '@portabletext/schema'
-import {Editor, type Operation} from 'slate'
-import {pluginWithoutHistory} from '../../history/slate-plugin.without-history'
-import {getCurrentUndoStepId} from '../../history/undo-step'
-import {createApplyPatch} from '../../internal-utils/applyPatch'
-import {debugWithName} from '../../internal-utils/debug'
-import {
-  insertNodePatch,
-  insertTextPatch,
-  mergeNodePatch,
-  moveNodePatch,
-  removeNodePatch,
-  removeTextPatch,
-  setNodePatch,
-  splitNodePatch,
-} from '../../internal-utils/operation-to-patches'
-import {isEqualToEmptyEditor} from '../../internal-utils/values'
-import type {PortableTextSlateEditor} from '../../types/slate-editor'
-import type {EditorActor} from '../editor-machine'
-import type {RelayActor} from '../relay-machine'
-import {IS_PROCESSING_REMOTE_CHANGES} from '../weakMaps'
-import {withRemoteChanges} from '../withChanges'
-import {isPatching, PATCHING, withoutPatching} from '../withoutPatching'
-
-const debug = debugWithName('plugin:withPatches')
-const debugVerbose = false
-
-interface Options {
-  editorActor: EditorActor
-  relayActor: RelayActor
-  subscriptions: Array<() => () => void>
-}
-
-export function createWithPatches({
-  editorActor,
-  relayActor,
-  subscriptions,
-}: Options): (editor: PortableTextSlateEditor) => PortableTextSlateEditor {
-  // The previous editor value are needed to figure out the _key of deleted nodes
-  // The editor.value would no longer contain that information if the node is already deleted.
-  let previousValue: PortableTextBlock[]
-
-  const applyPatch = createApplyPatch(editorActor.getSnapshot().context)
-
-  return function withPatches(editor: PortableTextSlateEditor) {
-    IS_PROCESSING_REMOTE_CHANGES.set(editor, false)
-    PATCHING.set(editor, true)
-    previousValue = [...editor.value]
-
-    const {apply} = editor
-    let bufferedPatches: Patch[] = []
-
-    const handleBufferedRemotePatches = () => {
-      if (bufferedPatches.length === 0) {
-        return
-      }
-      const patches = bufferedPatches
-      bufferedPatches = []
-      let changed = false
-
-      withRemoteChanges(editor, () => {
-        Editor.withoutNormalizing(editor, () => {
-          withoutPatching(editor, () => {
-            pluginWithoutHistory(editor, () => {
-              for (const patch of patches) {
-                if (debug.enabled) {
-                  debug(`Handling remote patch ${JSON.stringify(patch)}`)
-                }
-
-                try {
-                  changed = applyPatch(editor, patch)
-                } catch (error) {
-                  console.error(
-                    `Applying patch ${JSON.stringify(patch)} failed due to: ${error.message}`,
-                  )
-                }
-              }
-            })
-          })
-        })
-        if (changed) {
-          editor.normalize()
-          editor.onChange()
-        }
-      })
-    }
-
-    const handlePatches = ({patches}: {patches: Patch[]}) => {
-      const remotePatches = patches.filter((p) => p.origin !== 'local')
-      if (remotePatches.length === 0) {
-        return
-      }
-      bufferedPatches = bufferedPatches.concat(remotePatches)
-      handleBufferedRemotePatches()
-    }
-
-    subscriptions.push(() => {
-      debug('Subscribing to remote patches')
-      const sub = editorActor.on('patches', handlePatches)
-      return () => {
-        debug('Unsubscribing to remote patches')
-        sub.unsubscribe()
-      }
-    })
-
-    editor.apply = (operation: Operation): void | Editor => {
-      let patches: Patch[] = []
-
-      // Update previous children here before we apply
-      previousValue = editor.value
-
-      const editorWasEmpty = isEqualToEmptyEditor(
-        editorActor.getSnapshot().context.initialValue,
-        previousValue,
-        editorActor.getSnapshot().context.schema,
-      )
-
-      // Apply the operation
-      apply(operation)
-
-      const editorIsEmpty = isEqualToEmptyEditor(
-        editorActor.getSnapshot().context.initialValue,
-        editor.value,
-        editorActor.getSnapshot().context.schema,
-      )
-
-      if (!isPatching(editor)) {
-        if (debugVerbose && debug.enabled) {
-          debug(
-            `Editor is not producing patch for operation ${operation.type}`,
-            operation,
-          )
-        }
-        return editor
-      }
-
-      // If the editor was empty and now isn't, insert the placeholder into it.
-      if (
-        editorWasEmpty &&
-        !editorIsEmpty &&
-        operation.type !== 'set_selection'
-      ) {
-        patches.push(insert(previousValue, 'before', [0]))
-      }
-
-      switch (operation.type) {
-        case 'insert_text':
-          patches = [
-            ...patches,
-            ...insertTextPatch(
-              editorActor.getSnapshot().context.schema,
-              editor.children,
-              operation,
-              previousValue,
-            ),
-          ]
-          break
-        case 'remove_text':
-          patches = [
-            ...patches,
-            ...removeTextPatch(
-              editorActor.getSnapshot().context.schema,
-              editor.children,
-              operation,
-              previousValue,
-            ),
-          ]
-          break
-        case 'remove_node':
-          patches = [
-            ...patches,
-            ...removeNodePatch(
-              editorActor.getSnapshot().context.schema,
-              previousValue,
-              operation,
-            ),
-          ]
-          break
-        case 'split_node':
-          patches = [
-            ...patches,
-            ...splitNodePatch(
-              editorActor.getSnapshot().context.schema,
-              editor.children,
-              operation,
-              previousValue,
-            ),
-          ]
-          break
-        case 'insert_node':
-          patches = [
-            ...patches,
-            ...insertNodePatch(
-              editorActor.getSnapshot().context.schema,
-              editor.children,
-              operation,
-              previousValue,
-            ),
-          ]
-          break
-        case 'set_node':
-          patches = [
-            ...patches,
-            ...setNodePatch(
-              editorActor.getSnapshot().context.schema,
-              editor.children,
-              operation,
-            ),
-          ]
-          break
-        case 'merge_node':
-          patches = [
-            ...patches,
-            ...mergeNodePatch(
-              editorActor.getSnapshot().context.schema,
-              editor.children,
-              operation,
-              previousValue,
-            ),
-          ]
-          break
-        case 'move_node':
-          patches = [
-            ...patches,
-            ...moveNodePatch(
-              editorActor.getSnapshot().context.schema,
-              previousValue,
-              operation,
-            ),
-          ]
-          break
-        default:
-        // Do nothing
-      }
-
-      // Unset the value if a operation made the editor empty
-      if (
-        !editorWasEmpty &&
-        editorIsEmpty &&
-        ['merge_node', 'set_node', 'remove_text', 'remove_node'].includes(
-          operation.type,
-        )
-      ) {
-        patches = [...patches, unset([])]
-        relayActor.send({
-          type: 'unset',
-          previousValue,
-        })
-      }
-
-      // Prepend patches with setIfMissing if going from empty editor to something involving a patch.
-      if (editorWasEmpty && patches.length > 0) {
-        patches = [setIfMissing([], []), ...patches]
-      }
-
-      // Emit all patches
-      if (patches.length > 0) {
-        for (const patch of patches) {
-          editorActor.send({
-            type: 'internal.patch',
-            patch: {...patch, origin: 'local'},
-            operationId: getCurrentUndoStepId(editor),
-            value: editor.value,
-          })
-        }
-      }
-      return editor
-    }
-    return editor
-  }
-}