@opentiny/fluent-editor 4.0.0-alpha.6 → 4.0.0-alpha.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opentiny/fluent-editor",
   "type": "module",
-  "version": "4.0.0-alpha.6",
+  "version": "4.0.0-alpha.7",
   "description": "A rich text editor based on Quill 2.0, which extends rich modules and formats on the basis of Quill. It's powerful and out-of-the-box.",
   "author": "OpenTiny Team",
   "license": "MIT",
@@ -49,12 +49,19 @@
     "jest": "^26.6.3",
     "mathlive": "^0.101.0",
     "parchment": "^3.0.0",
+    "quill-cursors": "^4.0.4",
     "sass": "^1.90.0",
     "shelljs": "^0.8.4",
     "ts-jest": "^26.5.6",
     "ts-node": "^9.1.1",
     "typescript": "^4.9.5",
     "vite": "^5.0.0",
-    "vite-plugin-dts": "^4.3.0"
+    "vite-plugin-dts": "^4.3.0",
+    "y-indexeddb": "^9.0.12",
+    "y-protocols": "^1.0.6",
+    "y-quill": "^1.0.0",
+    "y-webrtc": "10.3.0",
+    "y-websocket": "^3.0.0",
+    "yjs": "^13.6.27"
   }
 }

package/types/modules/collaborative-editing/awareness/awareness.d.ts

@@ -0,0 +1,29 @@
+import { default as QuillCursors } from 'quill-cursors';
+import { Awareness } from 'y-protocols/awareness';
+import { default as FluentEditor } from '../../../core/fluent-editor';
+
+import * as Y from 'yjs';
+export interface AwarenessState {
+    name?: string;
+    color?: string;
+}
+export interface AwarenessEvents {
+    change?: (changes: {
+        added: number[];
+        updated: number[];
+        removed: number[];
+    }, transactionOrigin: any) => void;
+    update?: ({ added, updated, removed }: {
+        added: number[];
+        updated: number[];
+        removed: number[];
+    }, origin: any) => void;
+    destroy?: () => void;
+}
+export interface AwarenessOptions {
+    state?: AwarenessState;
+    events?: AwarenessEvents;
+    timeout?: number | undefined;
+}
+export declare function setupAwareness(options?: AwarenessOptions, defaultAwareness?: Awareness): Awareness | null;
+export declare function bindAwarenessToCursors(awareness: Awareness, cursorsModule: QuillCursors, quill: FluentEditor, yText: Y.Text): (() => void) | void;

package/types/modules/collaborative-editing/awareness/index.d.ts

@@ -0,0 +1,2 @@
+export * from './awareness';
+export * from './y-indexeddb';

package/types/modules/collaborative-editing/awareness/y-indexeddb.d.ts

@@ -0,0 +1,3 @@
+import { Doc } from 'yjs';
+
+export declare function setupIndexedDB(doc: Doc): () => void;

package/types/modules/collaborative-editing/collaborative-editing.d.ts

@@ -0,0 +1,25 @@
+import { default as FluentEditor } from '../../fluent-editor';
+import { UnifiedProvider } from './provider/providerRegistry';
+import { YjsOptions } from './types';
+import { default as QuillCursors } from 'quill-cursors';
+import { Awareness } from 'y-protocols/awareness';
+
+import * as Y from 'yjs';
+export declare class CollaborativeEditor {
+    quill: FluentEditor;
+    options: YjsOptions;
+    private ydoc;
+    private provider;
+    private awareness;
+    private cursors;
+    private cleanupBindings;
+    private clearIndexedDB;
+    constructor(quill: FluentEditor, options: YjsOptions);
+    getAwareness(): Awareness;
+    getProvider(): UnifiedProvider;
+    getYDoc(): Y.Doc;
+    get isConnected(): boolean;
+    get isSynced(): boolean;
+    getCursors(): QuillCursors;
+    destroy(): Promise<void>;
+}

package/types/modules/collaborative-editing/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module';
+export * from './types';

package/types/modules/collaborative-editing/module.d.ts

@@ -0,0 +1,12 @@
+import { default as FluentEditor } from '../../fluent-editor';
+
+export declare class CollaborationModule {
+    quill: FluentEditor;
+    options: any;
+    private collaborativeEditor;
+    constructor(quill: FluentEditor, options: any);
+    getCursors(): import('quill-cursors').default;
+    getAwareness(): import('y-protocols/awareness').Awareness;
+    getProvider(): import('./provider').UnifiedProvider;
+    destroy(): Promise<void>;
+}

package/types/modules/collaborative-editing/provider/index.d.ts

@@ -0,0 +1,3 @@
+export * from './providerRegistry';
+export * from './webrtc';
+export * from './websocket';

package/types/modules/collaborative-editing/provider/providerRegistry.d.ts

@@ -0,0 +1,26 @@
+import { Awareness } from 'y-protocols/awareness';
+import { ProviderEventHandlers } from '../types';
+
+import type * as Y from 'yjs';
+export type ProviderRegistry = Record<string, ProviderConstructor>;
+export type ProviderConstructor<T = any> = new (props: ProviderConstructorProps<T>) => UnifiedProvider;
+export type ProviderConstructorProps<T = any> = {
+    options: T;
+    awareness?: Awareness;
+    doc?: Y.Doc;
+} & ProviderEventHandlers;
+export interface UnifiedProvider extends ProviderEventHandlers {
+    awareness: Awareness;
+    document: Y.Doc;
+    type: 'webrtc' | 'websocket' | string;
+    connect: () => void;
+    destroy: () => void;
+    disconnect: () => void;
+    isConnected: boolean;
+    isSynced: boolean;
+}
+export declare function registerProviderType<T>(type: string, providerClass: ProviderConstructor<T>): void;
+export declare function getProviderClass(type: string): ProviderConstructor | undefined;
+export declare function createProvider({ type, ...props }: ProviderConstructorProps & {
+    type: string;
+}): UnifiedProvider;

package/types/modules/collaborative-editing/provider/webrtc.d.ts

@@ -0,0 +1,37 @@
+import { Awareness } from 'y-protocols/awareness';
+import { ProviderEventHandlers } from '../types';
+import { UnifiedProvider } from './providerRegistry';
+import { WebrtcProvider } from 'y-webrtc';
+
+import * as Y from 'yjs';
+export interface WebRTCProviderOptions {
+    roomName: string;
+    filterBcConns?: boolean;
+    maxConns?: number;
+    password?: string;
+    peerOpts?: Record<string, unknown>;
+    signaling?: string[];
+}
+export declare class WebRTCProviderWrapper implements UnifiedProvider {
+    private provider;
+    private _isConnected;
+    private _isSynced;
+    onConnect?: () => void;
+    onDisconnect?: () => void;
+    onError?: (error: Error) => void;
+    onSyncChange?: (isSynced: boolean) => void;
+    document: Y.Doc;
+    awareness: Awareness;
+    type: 'webrtc';
+    connect: () => void;
+    destroy: () => void;
+    disconnect: () => void;
+    constructor({ awareness, doc, options, onConnect, onDisconnect, onError, onSyncChange, }: {
+        options: WebRTCProviderOptions;
+        awareness?: Awareness;
+        doc?: Y.Doc;
+    } & ProviderEventHandlers);
+    get isConnected(): boolean;
+    get isSynced(): boolean;
+    getProvider(): WebrtcProvider;
+}

package/types/modules/collaborative-editing/provider/websocket.d.ts

@@ -0,0 +1,41 @@
+import { ProviderEventHandlers } from '../types';
+import { UnifiedProvider } from './providerRegistry';
+import { Awareness } from 'y-protocols/awareness';
+import { WebsocketProvider } from 'y-websocket';
+
+import * as Y from 'yjs';
+export interface WebsocketProviderOptions {
+    serverUrl: string;
+    roomName: string;
+    connect?: boolean;
+    awareness?: any;
+    params?: Record<string, string>;
+    protocols?: string[];
+    WebSocketPolyfill?: typeof WebSocket;
+    resyncInterval?: number;
+    maxBackoffTime?: number;
+    disableBc?: boolean;
+}
+export declare class WebsocketProviderWrapper implements UnifiedProvider {
+    private provider;
+    private _isConnected;
+    private _isSynced;
+    onConnect?: () => void;
+    onDisconnect?: () => void;
+    onError?: (error: Error) => void;
+    onSyncChange?: (isSynced: boolean) => void;
+    document: Y.Doc;
+    awareness: Awareness;
+    type: 'websocket';
+    connect: () => void;
+    destroy: () => void;
+    disconnect: () => void;
+    constructor({ awareness, doc, options, onConnect, onDisconnect, onError, onSyncChange, }: {
+        options: WebsocketProviderOptions;
+        awareness?: Awareness;
+        doc?: Y.Doc;
+    } & ProviderEventHandlers);
+    get isConnected(): boolean;
+    get isSynced(): boolean;
+    getProvider(): WebsocketProvider;
+}

package/types/modules/collaborative-editing/types.d.ts

@@ -0,0 +1,37 @@
+import { AwarenessOptions } from './awareness';
+import { WebRTCProviderOptions, WebsocketProviderOptions } from './provider';
+import type * as Y from 'yjs';
+export interface ProviderEventHandlers {
+    onConnect?: () => void;
+    onDisconnect?: () => void;
+    onError?: (error: Error) => void;
+    onSyncChange?: (isSynced: boolean) => void;
+}
+export interface BaseYjsProviderConfig extends ProviderEventHandlers {
+    options: Record<string, any>;
+    type: string;
+}
+export type WebRTCProviderConfig = BaseYjsProviderConfig & {
+    options: WebRTCProviderOptions;
+    type: 'webrtc';
+};
+export type WebsocketProviderConfig = BaseYjsProviderConfig & {
+    options: WebsocketProviderOptions;
+    type: 'websocket';
+};
+export type CustomProviderConfig = BaseYjsProviderConfig & {
+    options: Record<string, any>;
+    type: string;
+};
+export type CursorsConfig = boolean | object;
+export interface YjsOptions {
+    ydoc?: Y.Doc;
+    provider: (WebRTCProviderConfig | WebsocketProviderConfig | CustomProviderConfig);
+    awareness?: AwarenessOptions;
+    offline?: boolean;
+    cursors?: CursorsConfig;
+    onConnect?: () => void;
+    onDisconnect?: () => void;
+    onError?: (error: any) => void;
+    onSyncChange?: (isSynced: boolean) => void;
+}

package/types/modules/index.d.ts

@@ -1,3 +1,4 @@
+export * from './collaborative-editing';
 export * from './counter';
 export * from './custom-clipboard';
 export * from './custom-image';