@kerebron/extension-yjs 0.5.3 → 0.5.4

package/src/createNodeFromYElement.ts

@@ -0,0 +1,175 @@
+import * as PModel from 'prosemirror-model';
+import { Mark, Schema } from 'prosemirror-model';
+import * as Y from 'yjs';
+
+import type { BindingMetadata } from './ProsemirrorBinding.js';
+import { ySyncPluginKey } from './keys.js';
+import { isVisible } from './utils.js';
+import { yattr2markname } from './updateYFragment.js';
+
+export const attributesToMarks = (
+  attrs: { [s: string]: any },
+  schema: Schema,
+) => {
+  const marks: Array<Mark> = [];
+  for (const markName in attrs) {
+    // remove hashes if necessary
+    marks.push(schema.mark(yattr2markname(markName), attrs[markName]));
+  }
+  return marks;
+};
+
+export const createNodeIfNotExists = (
+  el: Y.XmlElement,
+  schema: PModel.Schema,
+  meta: BindingMetadata,
+  snapshot?: Y.Snapshot,
+  prevSnapshot?: Y.Snapshot,
+  computeYChange?: (arg0: 'removed' | 'added', arg1: Y.ID) => any,
+): PModel.Node | null => {
+  const node: PModel.Node = meta.mapping.get(el) as PModel.Node;
+  if (node === undefined) {
+    if (el instanceof Y.XmlElement) {
+      return createNodeFromYElement(
+        el,
+        schema,
+        meta,
+        snapshot,
+        prevSnapshot,
+        computeYChange,
+      );
+    } else {
+      throw new Error('methodUnimplemented'); // we are currently not handling hooks
+    }
+  }
+  return node;
+};
+
+export const createNodeFromYElement = (
+  el: Y.XmlElement,
+  schema: Schema,
+  meta: BindingMetadata,
+  snapshot?: Y.Snapshot,
+  prevSnapshot?: Y.Snapshot,
+  computeYChange?: (arg0: 'removed' | 'added', arg1: Y.ID) => any,
+): PModel.Node | null => {
+  const children: PModel.Node[] = [];
+  const createChildren = (type: Y.XmlElement | Y.XmlText) => {
+    if (type instanceof Y.XmlElement) {
+      const n = createNodeIfNotExists(
+        type,
+        schema,
+        meta,
+        snapshot,
+        prevSnapshot,
+        computeYChange,
+      );
+      if (n !== null) {
+        children.push(n);
+      }
+    } else {
+      // If the next ytext exists and was created by us, move the content to the current ytext.
+      // This is a fix for #160 -- duplication of characters when two Y.Text exist next to each
+      // other.
+      const nextytext: Y.ContentType = type._item?.right?.content?.type;
+
+      if (
+        nextytext &&
+        nextytext instanceof Y.Text && nextytext._item &&
+        !nextytext._item.deleted &&
+        nextytext._item.id.client === nextytext.doc!.clientID
+      ) {
+        type.applyDelta([
+          { retain: type.length },
+          ...nextytext.toDelta(),
+        ]);
+        nextytext.doc!.transact((tr) => {
+          nextytext._item?.delete(tr);
+        });
+      }
+
+      // now create the prosemirror text nodes
+      const ns = createTextNodesFromYText(
+        type,
+        schema,
+        meta,
+        snapshot,
+        prevSnapshot,
+        computeYChange,
+      );
+      if (ns !== null) {
+        ns.forEach((textchild) => {
+          if (textchild !== null) {
+            children.push(textchild);
+          }
+        });
+      }
+    }
+  };
+  if (snapshot === undefined || prevSnapshot === undefined) {
+    for (const item of el.toArray()) {
+      if (item instanceof Y.XmlHook) {
+        continue;
+      }
+      createChildren(item);
+    }
+  } else {
+    Y.typeListToArraySnapshot(el, new Y.Snapshot(prevSnapshot.ds, snapshot.sv))
+      .forEach(createChildren);
+  }
+  try {
+    const attrs = el.getAttributes(snapshot);
+    const item: Y.Item = el._item!;
+    if (snapshot !== undefined) {
+      const item: Y.Item = el._item!;
+      if (!isVisible(item, snapshot)) {
+        attrs.ychange = computeYChange
+          ? computeYChange('removed', item.id)
+          : { type: 'removed' };
+      } else if (!isVisible(item, prevSnapshot)) {
+        attrs.ychange = computeYChange
+          ? computeYChange('added', item.id)
+          : { type: 'added' };
+      }
+    }
+    const node = schema.node(el.nodeName, attrs, children);
+    meta.mapping.set(el, node);
+    return node;
+  } catch (e) {
+    // an error occured while creating the node. This is probably a result of a concurrent action.
+    el.doc?.transact((transaction) => {
+      el._item?.delete(transaction);
+    }, ySyncPluginKey);
+    meta.mapping.delete(el);
+    return null;
+  }
+};
+
+/**
+ * @private
+ */
+const createTextNodesFromYText = (
+  text: Y.XmlText,
+  schema: Schema,
+  _meta: BindingMetadata,
+  snapshot: Y.Snapshot,
+  prevSnapshot: Y.Snapshot,
+  computeYChange: (arg0: 'removed' | 'added', arg1: Y.ID) => any,
+): Array<PModel.Node> | null => {
+  const nodes: PModel.Node[] = [];
+  const deltas = text.toDelta(snapshot, prevSnapshot, computeYChange);
+  try {
+    for (let i = 0; i < deltas.length; i++) {
+      const delta = deltas[i];
+      nodes.push(
+        schema.text(delta.insert, attributesToMarks(delta.attributes, schema)),
+      );
+    }
+  } catch (e) {
+    text.doc?.transact((transaction) => {
+      text._item?.delete(transaction);
+    }, ySyncPluginKey);
+    return null;
+  }
+  return nodes;
+};

package/src/debug.ts

@@ -0,0 +1,218 @@
+import * as Y from 'yjs';
+import { isVisible } from './utils.js';
+
+interface YDebugConfig {
+  STRIKE: string;
+  RESET: string;
+  DIM: string;
+  isVisible: (item: Y.Item | null) => boolean;
+  renderDeleted: (text: string, item: Y.Item | null) => string;
+}
+
+const YAnsiDebugConfig: YDebugConfig = {
+  STRIKE: '\x1b[9m',
+  RESET: '\x1b[0m',
+  DIM: '\x1b[2m',
+  isVisible: () => true,
+  renderDeleted(text: string, item: Y.Item | null) {
+    if (item?.deleted) {
+      return this.STRIKE + text + this.RESET;
+    }
+    return text;
+  },
+};
+
+function indentText(text: string, indent: number = 0): string {
+  const indentStr = '  '.repeat(indent);
+  const lines = text.split('\n');
+  const indentedLines = lines.map((line) => indentStr + line);
+
+  if (indentedLines[indentedLines.length - 1] === indentStr) {
+    indentedLines[indentedLines.length - 1] = '';
+  }
+
+  return indentedLines.join('\n');
+}
+
+export function debugYNode(
+  node: Y.AbstractType<any>,
+  config: YDebugConfig = YAnsiDebugConfig,
+): string {
+  const {
+    STRIKE,
+    RESET,
+    DIM,
+  } = config;
+
+  const yDebugClient = (item: Y.Item | null) => {
+    if (!item) {
+      return '';
+    }
+    const { client, clock } = item.id;
+    return `\t${DIM}[${client}:${clock}]${RESET}`;
+  };
+
+  let retVal = '';
+
+  if (node instanceof Y.XmlText) {
+    if (!config.isVisible(node._item)) {
+      return '';
+    }
+
+    retVal += config.renderDeleted('XmlText', node._item) + ' {';
+
+    retVal += yDebugClient(node._item);
+    retVal += '\n';
+
+    let text = '';
+
+    for (let item = node._start; item; item = item.right) {
+      if (!config.isVisible(item)) {
+        continue;
+      }
+
+      if (item.content instanceof Y.ContentString) {
+        const content = item.content?.str || '';
+
+        text += config.renderDeleted(content, item);
+        text += yDebugClient(node._item);
+        text += '\n';
+      } else {
+        text += config.renderDeleted(
+          `Unhandled debug: ${typeof item.content}`,
+          item,
+        );
+        text += yDebugClient(node._item);
+        text += '\n';
+      }
+    }
+
+    retVal += indentText(text, 1);
+    retVal += `}\n`;
+
+    return retVal;
+  }
+
+  if (node instanceof Y.XmlElement) {
+    if (!config.isVisible(node._item)) {
+      return '';
+    }
+
+    retVal += config.renderDeleted(`<${node.nodeName}>`, node._item);
+    retVal += yDebugClient(node._item);
+    retVal += '\n';
+
+    retVal += indentText(
+      node.toArray()
+        .map((child) => {
+          return debugYNode(child, config);
+        })
+        .join('\n'),
+      1,
+    );
+
+    retVal += config.renderDeleted(`</${node.nodeName}>`, node._item);
+    return retVal;
+  }
+
+  if (node instanceof Y.XmlFragment) {
+    if (!config.isVisible(node._item)) {
+      return '';
+    }
+
+    retVal += config.renderDeleted(`Y.XmlFragment`, node._item);
+    retVal += yDebugClient(node._item);
+    retVal += '\n';
+
+    retVal += indentText(
+      node.toArray()
+        .map((child) => {
+          return debugYNode(child, config);
+        })
+        .join('\n'),
+      1,
+    );
+    return retVal;
+  }
+
+  if (node instanceof Y.Map) {
+    if (!config.isVisible(node._item)) {
+      return '';
+    }
+
+    const entries = Array.from(node.entries());
+
+    retVal += config.renderDeleted(`Y.Map(${entries.length})`, node._item);
+    retVal += yDebugClient(node._item);
+    retVal += '\n';
+
+    retVal += indentText(
+      entries
+        .map(([key, value]: [string, any]) =>
+          '- ' + key + ': ' + debugYNode(value, config)
+        )
+        .join('\n'),
+      1,
+    );
+    return retVal;
+  }
+
+  if (node instanceof Y.Array) {
+    if (!config.isVisible(node._item)) {
+      return '';
+    }
+
+    const arr: Y.Array<any> = node;
+
+    retVal += config.renderDeleted(`Y.Array(${arr._length})`, node._item);
+    retVal += yDebugClient(node._item);
+    retVal += '\n';
+
+    retVal += indentText(
+      arr
+        .map((value) => '- ' + debugYNode(value, config))
+        .join('\n'),
+      1,
+    );
+    return retVal;
+  }
+
+  if ('object' !== typeof node) {
+    retVal += '' + node;
+    return retVal;
+  }
+
+  throw new Error('Unhandled debug class: ' + node.constructor.name);
+}
+
+export function debugYDoc(
+  ydoc: Y.Doc,
+  config: YDebugConfig = YAnsiDebugConfig,
+): string {
+  const entries = Array.from(ydoc.share.entries());
+  let retVal = '';
+  for (const [key, value] of entries) {
+    retVal += `${key}: `;
+    retVal += debugYNode(value, config);
+    retVal += '\n';
+  }
+  return (`Y.Doc(${entries.length})\n` + indentText(retVal, 1)).trim();
+}
+
+export function debugYDocSnapshot(
+  ydoc: Y.Doc,
+  snapshot: Y.Snapshot,
+) {
+  const retVal = debugYDoc(ydoc, {
+    ...YAnsiDebugConfig,
+    isVisible: (item: Y.Item | null) => {
+      if (!item) return true;
+      return isVisible(item, snapshot);
+    },
+    renderDeleted(text: string) {
+      return text;
+    },
+  });
+
+  return ('Y.Snapshot\n' + indentText(retVal, 1)).trim();
+}

package/src/keys.ts

@@ -1,14 +1,14 @@
 import { PluginKey } from 'prosemirror-state';
-import { UndoPluginState } from './yUndoPlugin.js';
+import { type UndoPluginState } from './yUndoPlugin.js';
+import { type YSyncPluginState } from './ySyncPlugin.js';
+import { type YPositionPluginState } from './yPositionPlugin.js';
 
-/**
- * The unique prosemirror plugin key for syncPlugin
- */
-export const ySyncPluginKey = new PluginKey('y-sync');
+export const ySyncPluginKey = new PluginKey<YSyncPluginState>('y-sync');
 
-/**
- * The unique prosemirror plugin key for undoPlugin
- */
-export const yUndoPluginKey: PluginKey<UndoPluginState> = new PluginKey(
+export const yPositionPluginKey = new PluginKey<YPositionPluginState>(
+  'yjs-position',
+);
+
+export const yUndoPluginKey = new PluginKey<UndoPluginState>(
   'y-undo',
 );

package/src/lib.ts

@@ -7,7 +7,7 @@ import { ySyncPluginKey } from './keys.js';
 /**
  * Either a node if type is YXmlElement or an Array of text nodes if YXmlText
  */
-type ProsemirrorMapping = Map<Y.AbstractType<any>, Node>;
+export type ProsemirrorMapping = Map<Y.AbstractType<any>, Node | Array<Node>>;
 
 /**
  * Is null if no timeout is in progress.
@@ -192,7 +192,11 @@ export const relativePositionToAbsolutePosition = (
           pos += t._length;
         } else {
           const node = mapping.get(t);
-          pos += node?.nodeSize || 0;
+          if (Array.isArray(node)) {
+            pos += node.reduce((prev, curr) => prev + curr?.nodeSize || 0, 0);
+          } else {
+            pos += node?.nodeSize || 0;
+          }
         }
       }
       n = n.right;
@@ -218,7 +222,11 @@ export const relativePositionToAbsolutePosition = (
             pos += contentType._length;
           } else {
             const node = mapping.get(contentType);
-            pos += node?.nodeSize || 0;
+            if (Array.isArray(node)) {
+              pos += node.reduce((prev, curr) => prev + curr?.nodeSize || 0, 0);
+            } else {
+              pos += node?.nodeSize || 0;
+            }
           }
         }
         n = n.right;