@wangeditor-next/yjs 0.1.0

package/dist/module/custom-types.d.ts

@@ -0,0 +1,41 @@
+import type { Descendant, Editor, Element, Node } from 'slate';
+import type Y from 'yjs';
+export declare type DeltaAttributes = {
+    retain: number;
+    attributes: Record<string, unknown>;
+};
+export declare type DeltaRetain = {
+    retain: number;
+};
+export declare type DeltaDelete = {
+    delete: number;
+};
+export declare type DeltaInsert = {
+    insert: string | Y.XmlText;
+    attributes?: Record<string, unknown>;
+};
+export declare type InsertDelta = Array<DeltaInsert>;
+export declare type Delta = Array<DeltaRetain | DeltaDelete | DeltaInsert | DeltaAttributes>;
+export declare type TextRange = {
+    start: number;
+    end: number;
+};
+export declare type HistoryStackItem = {
+    meta: Map<string, unknown>;
+};
+export declare type YTarget = {
+    textRange: TextRange;
+    yParent: Y.XmlText;
+    slateParent: Element | Editor;
+    yTarget?: Y.XmlText;
+    slateTarget?: Node;
+    targetDelta: InsertDelta;
+};
+export declare type RelativeRange = {
+    anchor: Y.RelativePosition;
+    focus: Y.RelativePosition;
+};
+export declare type NodeElement = {
+    type: string;
+    children: Descendant[];
+};

package/dist/plugins/index.d.ts

@@ -0,0 +1,3 @@
+export * from './withYjs';
+export * from './withYHistory';
+export * from './withCursors';

package/dist/plugins/withCursors.d.ts

@@ -0,0 +1,55 @@
+import { Range } from 'slate';
+import { Awareness } from 'y-protocols/awareness';
+import * as Y from 'yjs';
+import { RelativeRange } from '../module/custom-types';
+import { YjsEditor } from './withYjs';
+export declare type CursorStateChangeEvent = {
+    added: number[];
+    updated: number[];
+    removed: number[];
+};
+export declare type RemoteCursorChangeEventListener = (event: CursorStateChangeEvent) => void;
+export declare type CursorState<TCursorData extends Record<string, unknown> = Record<string, unknown>> = {
+    relativeSelection: RelativeRange | null;
+    data?: TCursorData;
+    clientId: number;
+};
+export declare type CursorEditor<TCursorData extends Record<string, unknown> = Record<string, unknown>> = YjsEditor & {
+    awareness: Awareness;
+    cursorDataField: string;
+    selectionStateField: string;
+    sendCursorPosition: (range: Range | null) => void;
+    sendCursorData: (data: TCursorData) => void;
+};
+export declare const CursorEditor: {
+    isCursorEditor(value: unknown): value is CursorEditor<Record<string, unknown>>;
+    sendCursorPosition<TCursorData extends Record<string, unknown>>(editor: CursorEditor<TCursorData>, range?: Range | null): void;
+    sendCursorData<TCursorData_1 extends Record<string, unknown>>(editor: CursorEditor<TCursorData_1>, data: TCursorData_1): void;
+    on<TCursorData_2 extends Record<string, unknown>>(editor: CursorEditor<TCursorData_2>, event: 'change', handler: RemoteCursorChangeEventListener): void;
+    off<TCursorData_3 extends Record<string, unknown>>(editor: CursorEditor<TCursorData_3>, event: 'change', listener: RemoteCursorChangeEventListener): void;
+    cursorState<TCursorData_4 extends Record<string, unknown>>(editor: CursorEditor<TCursorData_4>, clientId: number): CursorState<TCursorData_4> | null;
+    cursorStates<TCursorData_5 extends Record<string, unknown>>(editor: CursorEditor<TCursorData_5>): Record<string, CursorState<TCursorData_5>>;
+};
+export declare type WithCursorsOptions<TCursorData extends Record<string, unknown> = Record<string, unknown>> = {
+    cursorStateField?: string;
+    cursorDataField?: string;
+    data?: TCursorData;
+    autoSend?: boolean;
+};
+export declare function withCursors<TCursorData extends Record<string, unknown>>(awareness: Awareness, options?: WithCursorsOptions<TCursorData>): <T extends YjsEditor>(editor: T) => T & import("slate").BaseEditor & {
+    sharedRoot: Y.XmlText;
+    localOrigin: unknown;
+    positionStorageOrigin: unknown;
+    applyRemoteEvents: (events: Y.YEvent<Y.XmlText>[], origin: unknown) => void;
+    storeLocalChange: (op: import("slate").BaseOperation) => void;
+    flushLocalChanges: () => void;
+    isLocalOrigin: (origin: unknown) => boolean;
+    connect: () => void;
+    disconnect: () => void;
+} & {
+    awareness: Awareness;
+    cursorDataField: string;
+    selectionStateField: string;
+    sendCursorPosition: (range: import("slate").BaseRange | null) => void;
+    sendCursorData: (data: TCursorData) => void;
+};

package/dist/plugins/withYHistory.d.ts

@@ -0,0 +1,34 @@
+import * as Y from 'yjs';
+import { YjsEditor } from './withYjs';
+export declare type YHistoryEditor = YjsEditor & {
+    undoManager: Y.UndoManager;
+    withoutSavingOrigin: unknown;
+    undo: () => void;
+    redo: () => void;
+};
+export declare const YHistoryEditor: {
+    isYHistoryEditor(value: unknown): value is YHistoryEditor;
+    canUndo(editor: YHistoryEditor): boolean;
+    canRedo(editor: YHistoryEditor): boolean;
+    isSaving(editor: YHistoryEditor): boolean;
+    withoutSaving(editor: YHistoryEditor, fn: () => void): void;
+};
+export declare type WithYHistoryOptions = NonNullable<ConstructorParameters<typeof Y.UndoManager>[1]> & {
+    withoutSavingOrigin?: unknown;
+};
+export declare function withYHistory(options?: WithYHistoryOptions): <T extends YjsEditor>(editor: T) => T & import("slate").BaseEditor & {
+    sharedRoot: Y.XmlText;
+    localOrigin: unknown;
+    positionStorageOrigin: unknown;
+    applyRemoteEvents: (events: Y.YEvent<Y.XmlText>[], origin: unknown) => void;
+    storeLocalChange: (op: import("slate").BaseOperation) => void;
+    flushLocalChanges: () => void;
+    isLocalOrigin: (origin: unknown) => boolean;
+    connect: () => void;
+    disconnect: () => void;
+} & {
+    undoManager: Y.UndoManager;
+    withoutSavingOrigin: unknown;
+    undo: () => void;
+    redo: () => void;
+};

package/dist/plugins/withYjs.d.ts

@@ -0,0 +1,52 @@
+import { BaseEditor, Descendant, Operation, Point } from 'slate';
+import * as Y from 'yjs';
+declare type LocalChange = {
+    op: Operation;
+    doc: Descendant[];
+    origin: unknown;
+};
+export declare type YjsEditor = BaseEditor & {
+    sharedRoot: Y.XmlText;
+    localOrigin: unknown;
+    positionStorageOrigin: unknown;
+    applyRemoteEvents: (events: Y.YEvent<Y.XmlText>[], origin: unknown) => void;
+    storeLocalChange: (op: Operation) => void;
+    flushLocalChanges: () => void;
+    isLocalOrigin: (origin: unknown) => boolean;
+    connect: () => void;
+    disconnect: () => void;
+};
+export declare const YjsEditor: {
+    isYjsEditor(value: unknown): value is YjsEditor;
+    localChanges(editor: YjsEditor): LocalChange[];
+    applyRemoteEvents(editor: YjsEditor, events: Y.YEvent<Y.XmlText>[], origin: unknown): void;
+    storeLocalChange(editor: YjsEditor, op: Operation): void;
+    flushLocalChanges(editor: YjsEditor): void;
+    connected(editor: YjsEditor): boolean;
+    connect(editor: YjsEditor): void;
+    disconnect(editor: YjsEditor): void;
+    isLocal(editor: YjsEditor): boolean;
+    origin(editor: YjsEditor): unknown;
+    withOrigin(editor: YjsEditor, origin: unknown, fn: () => void): void;
+    storePosition(editor: YjsEditor, key: string, point: Point): void;
+    removeStoredPosition(editor: YjsEditor, key: string): void;
+    position(editor: YjsEditor, key: string): Point | null | undefined;
+    storedPositionsRelative(editor: YjsEditor): Record<string, Y.RelativePosition>;
+};
+export declare type WithYjsOptions = {
+    autoConnect?: boolean;
+    localOrigin?: unknown;
+    positionStorageOrigin?: unknown;
+};
+export declare function withYjs(sharedRoot: Y.XmlText, options?: WithYjsOptions): <T extends BaseEditor>(editor: T) => T & BaseEditor & {
+    sharedRoot: Y.XmlText;
+    localOrigin: unknown;
+    positionStorageOrigin: unknown;
+    applyRemoteEvents: (events: Y.YEvent<Y.XmlText>[], origin: unknown) => void;
+    storeLocalChange: (op: import("slate").BaseOperation) => void;
+    flushLocalChanges: () => void;
+    isLocalOrigin: (origin: unknown) => boolean;
+    connect: () => void;
+    disconnect: () => void;
+};
+export {};

package/dist/utils/clone.d.ts

@@ -0,0 +1,4 @@
+import * as Y from 'yjs';
+import { InsertDelta } from '../module/custom-types';
+export declare function cloneInsertDeltaDeep(delta: InsertDelta): InsertDelta;
+export declare function cloneDeep(yText: Y.XmlText): Y.XmlText;

package/dist/utils/convert.d.ts

@@ -0,0 +1,7 @@
+import { Element, Node } from 'slate';
+import * as Y from 'yjs';
+import { DeltaInsert, InsertDelta } from '../module/custom-types';
+export declare function yTextToSlateElement(yText: Y.XmlText): Element;
+export declare function deltaInsertToSlateNode(insert: DeltaInsert): Node;
+export declare function slateNodesToInsertDelta(nodes: Node[]): InsertDelta;
+export declare function slateElementToYText({ children, ...attributes }: Element): Y.XmlText;

package/dist/utils/delta.d.ts

@@ -0,0 +1,7 @@
+import * as Y from 'yjs';
+import { DeltaInsert, InsertDelta } from '../module/custom-types';
+export declare function normalizeInsertDelta(delta: InsertDelta): InsertDelta;
+export declare function yTextToInsertDelta(yText: Y.XmlText): InsertDelta;
+export declare function getInsertLength({ insert }: DeltaInsert): number;
+export declare function getInsertDeltaLength(delta: InsertDelta): number;
+export declare function sliceInsertDelta(delta: InsertDelta, start: number, length: number): InsertDelta;

package/dist/utils/location.d.ts

@@ -0,0 +1,11 @@
+import { Element, Node, Path } from 'slate';
+import * as Y from 'yjs';
+import { YTarget } from '../module/custom-types';
+export declare function getSlateNodeYLength(node: Node | undefined): number;
+export declare function slatePathOffsetToYOffset(element: Element, pathOffset: number): number;
+export declare function getYTarget(yRoot: Y.XmlText, slateRoot: Node, path: Path): YTarget;
+export declare function yOffsetToSlateOffsets(parent: Element, yOffset: number, opts?: {
+    assoc?: number;
+    insert?: boolean;
+}): [number, number];
+export declare function getSlatePath(sharedRoot: Y.XmlText, slateRoot: Node, yText: Y.XmlText): Path;

package/dist/utils/object.d.ts

@@ -0,0 +1,9 @@
+declare type InspectableObject = Record<string | number | symbol, unknown>;
+export declare function isPlainObject(o: unknown): o is InspectableObject;
+export declare function deepEquals(node: InspectableObject, another: InspectableObject): boolean;
+export declare function pick<TObj, TKeys extends keyof TObj>(obj: TObj, ...keys: TKeys[]): Pick<TObj, TKeys>;
+export declare function omit<TObj, TKeys extends keyof TObj>(obj: TObj, ...keys: TKeys[]): Omit<TObj, TKeys>;
+export declare function omitNullEntries<TObj>(obj: TObj): {
+    [K in keyof TObj]: TObj[K] extends null ? never : K;
+};
+export {};

package/dist/utils/position.d.ts

@@ -0,0 +1,19 @@
+import { BasePoint, BaseRange, Node } from 'slate';
+import * as Y from 'yjs';
+import { InsertDelta, RelativeRange } from '../module/custom-types';
+export declare const STORED_POSITION_PREFIX = "__slateYjsStoredPosition_";
+export declare function slatePointToRelativePosition(sharedRoot: Y.XmlText, slateRoot: Node, point: BasePoint): Y.RelativePosition;
+export declare function absolutePositionToSlatePoint(sharedRoot: Y.XmlText, slateRoot: Node, { type, index, assoc }: Y.AbsolutePosition): BasePoint | null;
+export declare function relativePositionToSlatePoint(sharedRoot: Y.XmlText, slateRoot: Node, pos: Y.RelativePosition): BasePoint | null;
+export declare function getStoredPosition(sharedRoot: Y.XmlText, key: string): Y.RelativePosition | null;
+export declare function getStoredPositions(sharedRoot: Y.XmlText): Record<string, Y.RelativePosition>;
+export declare function removeStoredPosition(sharedRoot: Y.XmlText, key: string): void;
+export declare function setStoredPosition(sharedRoot: Y.XmlText, key: string, position: Y.RelativePosition): void;
+export declare function getStoredPositionsInDeltaAbsolute(sharedRoot: Y.XmlText, yText: Y.XmlText, delta: InsertDelta, deltaOffset?: number): {
+    '': {
+        [k: string]: Y.AbsolutePosition;
+    };
+};
+export declare function restoreStoredPositionsWithDeltaAbsolute(sharedRoot: Y.XmlText, yText: Y.XmlText, absolutePositions: Record<string, Record<string, Y.AbsolutePosition>>, delta: InsertDelta, newDeltaOffset?: number, previousDeltaOffset?: number, path?: string): void;
+export declare function slateRangeToRelativeRange(sharedRoot: Y.XmlText, slateRoot: Node, range: BaseRange): RelativeRange;
+export declare function relativeRangeToSlateRange(sharedRoot: Y.XmlText, slateRoot: Node, range: RelativeRange): BaseRange | null;

package/dist/utils/slate.d.ts

@@ -0,0 +1,2 @@
+import { BaseText, Descendant } from 'slate';
+export declare function getProperties<TNode extends Descendant>(node: TNode): Omit<TNode, TNode extends BaseText ? 'text' : 'children'>;

package/dist/utils/yjs.d.ts

@@ -0,0 +1,4 @@
+import * as Y from 'yjs';
+export declare function assertDocumentAttachment<T extends Y.AbstractType<any>>(sharedType: T): asserts sharedType is T & {
+    doc: NonNullable<T['doc']>;
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@wangeditor-next/yjs",
+  "sideEffects": false,
+  "version": "0.1.0",
+  "author": "cycleccc <2991205548@qq.com>",
+  "contributors": [],
+  "description": "Yjs binding for wangeditor-next.",
+  "homepage": "https://github.com/cycleccc/wangEditor#readme",
+  "keywords": [
+    "slate",
+    "wangEditor",
+    "yjs",
+    "collaborative"
+  ],
+  "license": "MIT",
+  "types": "dist/index.d.ts",
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "unpkg": "dist/index.global.js",
+  "exports": {
+    "require": "./dist/index.js",
+    "default": "./dist/index.esm.js"
+  },
+  "browser": {
+    "./dist/index.js": "./dist/index.js",
+    "./dist/index.esm.js": "./dist/index.esm.js"
+  },
+  "directories": {
+    "lib": "dist",
+    "test": "__tests__"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cycleccc/wangEditor.git"
+  },
+  "scripts": {
+    "test": "jest",
+    "test-c": "jest --coverage",
+    "dev": "cross-env NODE_ENV=development rollup -c rollup.config.js",
+    "dev-watch": "cross-env NODE_ENV=development rollup -c rollup.config.js -w",
+    "build": "cross-env NODE_ENV=production rollup -c rollup.config.js",
+    "dev-size-stats": "cross-env NODE_ENV=development:size_stats rollup -c rollup.config.js",
+    "size-stats": "cross-env NODE_ENV=production:size_stats rollup -c rollup.config.js"
+  },
+  "peerDependencies": {
+    "@wangeditor-next/core": "1.x",
+    "slate": "^0.72.0",
+    "yjs": "^13.5.29"
+  },
+  "bugs": {
+    "url": "https://github.com/cycleccc/wangEditor/issues"
+  },
+  "dependencies": {
+    "y-protocols": "^1.0.5"
+  },
+  "devDependencies": {
+    "slate": "^0.72.0",
+    "typescript": "^4.6.3",
+    "yjs": "^13.5.29"
+  }
+}