@axure/y-prosemirror 1.3.7-fork.2

package/src/plugins/undo-plugin.js

@@ -0,0 +1,126 @@
+import { Plugin } from 'prosemirror-state'
+
+import { createRecoverableSelection } from './sync-plugin.js'
+import { UndoManager, Item, ContentType, XmlElement, Text } from 'yjs'
+import { yUndoPluginKey, ySyncPluginKey } from './keys.js'
+
+/**
+ * @typedef {Object} UndoPluginState
+ * @property {import('yjs').UndoManager} undoManager
+ * @property {ReturnType<typeof createRecoverableSelection> | null} prevSel
+ * @property {boolean} hasUndoOps
+ * @property {boolean} hasRedoOps
+ */
+
+/**
+ * Undo the last user action
+ *
+ * @param {import('prosemirror-state').EditorState} state
+ * @return {boolean} whether a change was undone
+ */
+export const undo = state => yUndoPluginKey.getState(state)?.undoManager?.undo() != null
+
+/**
+ * Redo the last user action
+ *
+ * @param {import('prosemirror-state').EditorState} state
+ * @return {boolean} whether a change was undone
+ */
+export const redo = state => yUndoPluginKey.getState(state)?.undoManager?.redo() != null
+
+/**
+ * Undo the last user action if there are undo operations available
+ * @type {import('prosemirror-state').Command}
+ */
+export const undoCommand = (state, dispatch) => dispatch == null ? yUndoPluginKey.getState(state)?.undoManager?.canUndo() : undo(state)
+
+/**
+ * Redo the last user action if there are redo operations available
+ * @type {import('prosemirror-state').Command}
+ */
+export const redoCommand = (state, dispatch) => dispatch == null ? yUndoPluginKey.getState(state)?.undoManager?.canRedo() : redo(state)
+
+export const defaultProtectedNodes = new Set(['paragraph'])
+
+/**
+ * @param {import('yjs').Item} item
+ * @param {Set<string>} protectedNodes
+ * @returns {boolean}
+ */
+export const defaultDeleteFilter = (item, protectedNodes) => !(item instanceof Item) ||
+  !(item.content instanceof ContentType) ||
+  !(item.content.type instanceof Text ||
+  (item.content.type instanceof XmlElement && protectedNodes.has(item.content.type.nodeName))) ||
+  item.content.type._length === 0
+
+/**
+ * @param {object} [options]
+ * @param {Set<string>} [options.protectedNodes]
+ * @param {any[]} [options.trackedOrigins]
+ * @param {import('yjs').UndoManager | null} [options.undoManager]
+ */
+export const yUndoPlugin = ({ protectedNodes = defaultProtectedNodes, trackedOrigins = [], undoManager = null } = {}) => new Plugin({
+  key: yUndoPluginKey,
+  state: {
+    init: (initargs, state) => {
+      // TODO: check if plugin order matches and fix
+      const ystate = ySyncPluginKey.getState(state)
+      const _undoManager = undoManager || new UndoManager(ystate.type, {
+        trackedOrigins: new Set([ySyncPluginKey].concat(trackedOrigins)),
+        deleteFilter: (item) => defaultDeleteFilter(item, protectedNodes),
+        captureTransaction: tr => tr.meta.get('addToHistory') !== false
+      })
+      return {
+        undoManager: _undoManager,
+        prevSel: null,
+        hasUndoOps: _undoManager.undoStack.length > 0,
+        hasRedoOps: _undoManager.redoStack.length > 0
+      }
+    },
+    apply: (tr, val, oldState, state) => {
+      const binding = ySyncPluginKey.getState(state).binding
+      const undoManager = val.undoManager
+      const hasUndoOps = undoManager.undoStack.length > 0
+      const hasRedoOps = undoManager.redoStack.length > 0
+      if (binding) {
+        return {
+          undoManager,
+          prevSel: createRecoverableSelection(binding, oldState),
+          hasUndoOps,
+          hasRedoOps
+        }
+      } else {
+        if (hasUndoOps !== val.hasUndoOps || hasRedoOps !== val.hasRedoOps) {
+          return Object.assign({}, val, {
+            hasUndoOps: undoManager.undoStack.length > 0,
+            hasRedoOps: undoManager.redoStack.length > 0
+          })
+        } else { // nothing changed
+          return val
+        }
+      }
+    }
+  },
+  view: view => {
+    const undoManager = yUndoPluginKey.getState(view.state).undoManager
+    undoManager.on('stack-item-added', ({ stackItem }) => {
+      const ystate = ySyncPluginKey.getState(view.state)
+      const binding = ystate.binding
+      if (binding) {
+        stackItem.meta.set(binding, binding.beforePatchSelection)
+      }
+    })
+    undoManager.on('stack-item-pop', ({ stackItem }) => {
+      const ystate = ySyncPluginKey.getState(view.state)
+      const binding = ystate.binding
+      if (binding) {
+        binding.beforeTransactionSelection = stackItem.meta.get(binding) || binding.beforeTransactionSelection
+      }
+    })
+    return {
+      destroy: () => {
+        undoManager.destroy()
+      }
+    }
+  }
+})

package/src/utils.js

@@ -0,0 +1,20 @@
+import * as sha256 from 'lib0/hash/sha256'
+import * as buf from 'lib0/buffer'
+
+/**
+ * Custom function to transform sha256 hash to N byte
+ *
+ * @param {Uint8Array} digest
+ */
+const _convolute = digest => {
+  const N = 6
+  for (let i = N; i < digest.length; i++) {
+    digest[i % N] = digest[i % N] ^ digest[i]
+  }
+  return digest.slice(0, N)
+}
+
+/**
+ * @param {any} json
+ */
+export const hashOfJSON = (json) => buf.toBase64(_convolute(sha256.digest(buf.encodeAny(json))))

package/src/y-prosemirror.js

@@ -0,0 +1,11 @@
+export * from './plugins/cursor-plugin.js'
+export { ySyncPlugin, isVisible, getRelativeSelection, ProsemirrorBinding, updateYFragment } from './plugins/sync-plugin.js'
+export * from './plugins/undo-plugin.js'
+export * from './plugins/keys.js'
+export {
+  absolutePositionToRelativePosition, relativePositionToAbsolutePosition, setMeta,
+  prosemirrorJSONToYDoc, yDocToProsemirrorJSON, yDocToProsemirror, prosemirrorToYDoc,
+  prosemirrorJSONToYXmlFragment, yXmlFragmentToProsemirrorJSON, yXmlFragmentToProsemirror,
+  prosemirrorToYXmlFragment, yXmlFragmentToProseMirrorRootNode, yXmlFragmentToProseMirrorFragment,
+  initProseMirrorDoc
+} from './lib.js'