@tiptap/y-tiptap 3.0.0-beta.2 → 3.0.0-beta.3

package/README.md

@@ -16,7 +16,7 @@ This binding maps a Y.XmlFragment to the ProseMirror state.
 ```js
 import { ySyncPlugin, yCursorPlugin, yUndoPlugin, undo, redo, initProseMirrorDoc } from '@tiptap/y-tiptap'
 import { exampleSetup } from 'prosemirror-example-setup'
-import { keymap } from '@tiptap/pm/keymap'
+import { keymap } from 'prosemirror-keymap'
 ..
 
 const type = ydocument.get('prosemirror', Y.XmlFragment)

package/dist/src/lib.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Utility method to convert a Prosemirror Doc Node into a Y.Doc.
+ *
+ * This can be used when importing existing content to Y.Doc for the first time,
+ * note that this should not be used to rehydrate a Y.Doc from a database once
+ * collaboration has begun as all history will be lost
+ *
+ * @param {Node} doc
+ * @param {string} xmlFragment
+ * @return {Y.Doc}
+ */
+export function prosemirrorToYDoc(doc: Node, xmlFragment?: string): Y.Doc;
+/**
+ * Utility method to update an empty Y.XmlFragment with content from a Prosemirror Doc Node.
+ *
+ * This can be used when importing existing content to Y.Doc for the first time,
+ * note that this should not be used to rehydrate a Y.Doc from a database once
+ * collaboration has begun as all history will be lost
+ *
+ * Note: The Y.XmlFragment does not need to be part of a Y.Doc document at the time that this
+ * method is called, but it must be added before any other operations are performed on it.
+ *
+ * @param {Node} doc prosemirror document.
+ * @param {Y.XmlFragment} [xmlFragment] If supplied, an xml fragment to be
+ *   populated from the prosemirror state; otherwise a new XmlFragment will be created.
+ * @return {Y.XmlFragment}
+ */
+export function prosemirrorToYXmlFragment(doc: Node, xmlFragment?: Y.XmlFragment): Y.XmlFragment;
+/**
+ * Utility method to convert Prosemirror compatible JSON into a Y.Doc.
+ *
+ * This can be used when importing existing content to Y.Doc for the first time,
+ * note that this should not be used to rehydrate a Y.Doc from a database once
+ * collaboration has begun as all history will be lost
+ *
+ * @param {Schema} schema
+ * @param {any} state
+ * @param {string} xmlFragment
+ * @return {Y.Doc}
+ */
+export function prosemirrorJSONToYDoc(schema: Schema, state: any, xmlFragment?: string): Y.Doc;
+/**
+ * Utility method to convert Prosemirror compatible JSON to a Y.XmlFragment
+ *
+ * This can be used when importing existing content to Y.Doc for the first time,
+ * note that this should not be used to rehydrate a Y.Doc from a database once
+ * collaboration has begun as all history will be lost
+ *
+ * @param {Schema} schema
+ * @param {any} state
+ * @param {Y.XmlFragment} [xmlFragment] If supplied, an xml fragment to be
+ *   populated from the prosemirror state; otherwise a new XmlFragment will be created.
+ * @return {Y.XmlFragment}
+ */
+export function prosemirrorJSONToYXmlFragment(schema: Schema, state: any, xmlFragment?: Y.XmlFragment): Y.XmlFragment;
+/**
+ * @deprecated Use `yXmlFragmentToProseMirrorRootNode` instead
+ *
+ * Utility method to convert a Y.Doc to a Prosemirror Doc node.
+ *
+ * @param {Schema} schema
+ * @param {Y.Doc} ydoc
+ * @return {Node}
+ */
+export function yDocToProsemirror(schema: Schema, ydoc: Y.Doc): Node;
+/**
+ *
+ * @deprecated Use `yXmlFragmentToProseMirrorRootNode` instead
+ *
+ * Utility method to convert a Y.XmlFragment to a Prosemirror Doc node.
+ *
+ * @param {Schema} schema
+ * @param {Y.XmlFragment} xmlFragment
+ * @return {Node}
+ */
+export function yXmlFragmentToProsemirror(schema: Schema, xmlFragment: Y.XmlFragment): Node;
+/**
+ *
+ * @deprecated Use `yXmlFragmentToProseMirrorRootNode` instead
+ *
+ * Utility method to convert a Y.Doc to Prosemirror compatible JSON.
+ *
+ * @param {Y.Doc} ydoc
+ * @param {string} xmlFragment
+ * @return {Record<string, any>}
+ */
+export function yDocToProsemirrorJSON(ydoc: Y.Doc, xmlFragment?: string): Record<string, any>;
+/**
+ * @deprecated Use `yXmlFragmentToProseMirrorRootNode` instead
+ *
+ * Utility method to convert a Y.Doc to Prosemirror compatible JSON.
+ *
+ * @param {Y.XmlFragment} xmlFragment The fragment, which must be part of a Y.Doc.
+ * @return {Record<string, any>}
+ */
+export function yXmlFragmentToProsemirrorJSON(xmlFragment: Y.XmlFragment): Record<string, any>;
+export function setMeta(view: any, key: any, value: any): void;
+export function absolutePositionToRelativePosition(pos: number, type: Y.XmlFragment, mapping: ProsemirrorMapping): any;
+export function relativePositionToAbsolutePosition(y: Y.Doc, documentType: Y.XmlFragment, relPos: any, mapping: ProsemirrorMapping): null | number;
+export function yXmlFragmentToProseMirrorFragment(yXmlFragment: Y.XmlFragment, schema: Schema): Fragment;
+export function yXmlFragmentToProseMirrorRootNode(yXmlFragment: Y.XmlFragment, schema: Schema): Node;
+export function initProseMirrorDoc(yXmlFragment: Y.XmlFragment, schema: Schema): {
+    doc: Node;
+    meta: {
+        mapping: Map<any, any>;
+        isOMark: Map<any, any>;
+    };
+    mapping: Map<any, any>;
+};
+/**
+ * Either a node if type is YXmlElement or an Array of text nodes if YXmlText
+ */
+export type ProsemirrorMapping = Map<Y.AbstractType<any>, Node | Array<Node>>;
+import { Node } from 'prosemirror-model';
+import * as Y from 'yjs';
+import { Schema } from 'prosemirror-model';
+import { Fragment } from 'prosemirror-model';

package/dist/src/plugins/cursor-plugin.d.ts

@@ -0,0 +1,17 @@
+export function defaultAwarenessStateFilter(currentClientId: number, userClientId: number, _user: any): boolean;
+export function defaultCursorBuilder(user: any): HTMLElement;
+export function defaultSelectionBuilder(user: any): import('prosemirror-view').DecorationAttrs;
+export function createDecorations(state: any, awareness: Awareness, awarenessFilter: (arg0: number, arg1: number, arg2: any) => boolean, createCursor: (user: {
+    name: string;
+    color: string;
+}, clientId: number) => Element, createSelection: (user: {
+    name: string;
+    color: string;
+}, clientId: number) => import('prosemirror-view').DecorationAttrs): any;
+export function yCursorPlugin(awareness: Awareness, { awarenessStateFilter, cursorBuilder, selectionBuilder, getSelection }?: {
+    awarenessStateFilter?: (arg0: any, arg1: any, arg2: any) => boolean;
+    cursorBuilder?: (user: any, clientId: number) => HTMLElement;
+    selectionBuilder?: (user: any, clientId: number) => import('prosemirror-view').DecorationAttrs;
+    getSelection?: (arg0: any) => any;
+}, cursorStateField?: string): any;
+import { Awareness } from "y-protocols/awareness";

package/dist/src/plugins/keys.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The unique prosemirror plugin key for syncPlugin
+ *
+ * @public
+ */
+export const ySyncPluginKey: PluginKey<any>;
+/**
+ * The unique prosemirror plugin key for undoPlugin
+ *
+ * @public
+ */
+export const yUndoPluginKey: PluginKey<any>;
+/**
+ * The unique prosemirror plugin key for cursorPlugin
+ *
+ * @public
+ */
+export const yCursorPluginKey: PluginKey<any>;
+import { PluginKey } from 'prosemirror-state';

package/dist/src/plugins/sync-plugin.d.ts

@@ -0,0 +1,125 @@
+export function createEmptyMeta(): {
+    mapping: Map<any, any>;
+    isOMark: Map<any, any>;
+};
+export function isVisible(item: Y.Item, snapshot?: Y.Snapshot): boolean;
+export function ySyncPlugin(yXmlFragment: Y.XmlFragment, { colors, colorMapping, permanentUserData, onFirstRender, mapping }?: YSyncOpts): any;
+export function getRelativeSelection(pmbinding: ProsemirrorBinding, state: import('prosemirror-state').EditorState): {
+    type: any;
+    anchor: any;
+    head: any;
+};
+/**
+ * Binding for prosemirror.
+ *
+ * @protected
+ */
+export class ProsemirrorBinding {
+    /**
+     * @param {Y.XmlFragment} yXmlFragment The bind source
+     * @param {ProsemirrorMapping} mapping
+     */
+    constructor(yXmlFragment: Y.XmlFragment, mapping?: ProsemirrorMapping);
+    type: Y.XmlFragment;
+    /**
+     * this will be set once the view is created
+     * @type {any}
+     */
+    prosemirrorView: any;
+    mux: import("lib0/mutex").mutex;
+    mapping: ProsemirrorMapping;
+    /**
+     * Is overlapping mark - i.e. mark does not exclude itself.
+     *
+     * @type {Map<import('prosemirror-model').MarkType, boolean>}
+     */
+    isOMark: Map<import('prosemirror-model').MarkType, boolean>;
+    _observeFunction: any;
+    /**
+     * @type {Y.Doc}
+     */
+    doc: Y.Doc;
+    /**
+     * current selection as relative positions in the Yjs model
+     */
+    beforeTransactionSelection: {
+        type: any;
+        anchor: any;
+        head: any;
+    };
+    beforeAllTransactions: () => void;
+    afterAllTransactions: () => void;
+    _domSelectionInView: boolean;
+    /**
+     * Create a transaction for changing the prosemirror state.
+     *
+     * @returns
+     */
+    get _tr(): any;
+    _isLocalCursorInView(): boolean;
+    _isDomSelectionInView(): boolean;
+    /**
+     * @param {Y.Snapshot} snapshot
+     * @param {Y.Snapshot} prevSnapshot
+     */
+    renderSnapshot(snapshot: Y.Snapshot, prevSnapshot: Y.Snapshot): void;
+    unrenderSnapshot(): void;
+    _forceRerender(): void;
+    /**
+     * @param {Y.Snapshot|Uint8Array} snapshot
+     * @param {Y.Snapshot|Uint8Array} prevSnapshot
+     * @param {Object} pluginState
+     */
+    _renderSnapshot(snapshot: Y.Snapshot | Uint8Array, prevSnapshot: Y.Snapshot | Uint8Array, pluginState: any): void;
+    /**
+     * @param {Array<Y.YEvent<any>>} events
+     * @param {Y.Transaction} transaction
+     */
+    _typeChanged(events: Array<Y.YEvent<any>>, transaction: Y.Transaction): void;
+    /**
+     * @param {import('prosemirror-model').Node} doc
+     */
+    _prosemirrorChanged(doc: import('prosemirror-model').Node): void;
+    /**
+     * View is ready to listen to changes. Register observers.
+     * @param {any} prosemirrorView
+     */
+    initView(prosemirrorView: any): void;
+    destroy(): void;
+}
+export function createNodeFromYElement(el: Y.XmlElement, schema: any, meta: BindingMetadata, snapshot?: Y.Snapshot, prevSnapshot?: Y.Snapshot, computeYChange?: (arg0: 'removed' | 'added', arg1: Y.ID) => any): PModel.Node | null;
+export function yattr2markname(attrName: string): string;
+export function attributesToMarks(attrs: {
+    [x: string]: any;
+}, schema: import('prosemirror-model').Schema): PModel.Mark[];
+export function updateYFragment(y: {
+    transact: Function;
+}, yDomFragment: Y.XmlFragment, pNode: any, meta: BindingMetadata): void;
+export type BindingMetadata = {
+    mapping: ProsemirrorMapping;
+    /**
+     * - is overlapping mark
+     */
+    isOMark: Map<import('prosemirror-model').MarkType, boolean>;
+};
+/**
+ * Either a node if type is YXmlElement or an Array of text nodes if YXmlText
+ */
+export type ProsemirrorMapping = Map<Y.AbstractType<any>, PModel.Node | Array<PModel.Node>>;
+export type ColorDef = {
+    light: string;
+    dark: string;
+};
+export type YSyncOpts = {
+    colors?: Array<ColorDef>;
+    colorMapping?: Map<string, ColorDef>;
+    permanentUserData?: Y.PermanentUserData | null;
+    mapping?: ProsemirrorMapping;
+    /**
+     * Fired when the content from Yjs is initially rendered to ProseMirror
+     */
+    onFirstRender?: Function;
+};
+export type NormalizedPNodeContent = Array<Array<PModel.Node> | PModel.Node>;
+import * as Y from 'yjs';
+import * as PModel from 'prosemirror-model';

package/dist/src/plugins/undo-plugin.d.ts

@@ -0,0 +1,15 @@
+export function undo(state: any): boolean;
+export function redo(state: any): boolean;
+export const defaultProtectedNodes: Set<string>;
+export function defaultDeleteFilter(item: any, protectedNodes: any): boolean;
+export function yUndoPlugin({ protectedNodes, trackedOrigins, undoManager }?: {
+    protectedNodes?: Set<string>;
+    trackedOrigins?: any[];
+    undoManager?: any;
+}): Plugin<{
+    undoManager: any;
+    prevSel: any;
+    hasUndoOps: boolean;
+    hasRedoOps: boolean;
+}>;
+import { Plugin } from 'prosemirror-state';

package/dist/src/utils.d.ts

@@ -0,0 +1 @@
+export function hashOfJSON(json: any): string;

package/dist/src/y-tiptap.d.ts

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

package/dist/y-tiptap.cjs

@@ -13,7 +13,6 @@ var object = require('lib0/object');
 var set = require('lib0/set');
 var diff = require('lib0/diff');
 var error = require('lib0/error');
-var state = require('@tiptap/pm/state');
 var random = require('lib0/random');
 var environment = require('lib0/environment');
 var dom = require('lib0/dom');
@@ -59,21 +58,21 @@ var buf__namespace = /*#__PURE__*/_interopNamespace(buf);
  *
  * @public
  */
-const ySyncPluginKey = new state.PluginKey('y-sync');
+const ySyncPluginKey = new prosemirrorState.PluginKey('y-sync');
 
 /**
  * The unique prosemirror plugin key for undoPlugin
  *
  * @public
  */
-const yUndoPluginKey = new state.PluginKey('y-undo');
+const yUndoPluginKey = new prosemirrorState.PluginKey('y-undo');
 
 /**
  * The unique prosemirror plugin key for cursorPlugin
  *
  * @public
  */
-const yCursorPluginKey = new state.PluginKey('yjs-cursor');
+const yCursorPluginKey = new prosemirrorState.PluginKey('yjs-cursor');
 
 /**
  * Custom function to transform sha256 hash to N byte
@@ -2088,7 +2087,7 @@ const defaultDeleteFilter = (item, protectedNodes) => !(item instanceof Y.Item)
   (item.content.type instanceof Y.XmlElement && protectedNodes.has(item.content.type.nodeName))) ||
 item.content.type._length === 0;
 
-const yUndoPlugin = ({ protectedNodes = defaultProtectedNodes, trackedOrigins = [], undoManager = null } = {}) => new state.Plugin({
+const yUndoPlugin = ({ protectedNodes = defaultProtectedNodes, trackedOrigins = [], undoManager = null } = {}) => new prosemirrorState.Plugin({
   key: yUndoPluginKey,
   state: {
     init: (initargs, state) => {