@hocuspocus/provider 2.13.5 → 3.0.0-rc.0

package/dist/packages/transformer/src/Tiptap.d.ts

@@ -1,6 +1,6 @@
-import { Doc } from 'yjs';
-import { Extensions } from '@tiptap/core';
-import { Transformer } from './types.js';
+import type { Doc } from 'yjs';
+import type { Extensions } from '@tiptap/core';
+import type { Transformer } from './types.js';
 export declare class Tiptap implements Transformer {
     defaultExtensions: Extensions;
     extensions(extensions: Extensions): Tiptap;

package/dist/packages/transformer/src/types.d.ts

@@ -1,4 +1,4 @@
-import { Doc } from 'yjs';
+import type { Doc } from 'yjs';
 export interface Transformer {
     fromYdoc: (document: Doc, fieldName?: string | Array<string>) => any;
     toYdoc: (document: any, fieldName: string) => Doc;

package/dist/tests/utils/newHocuspocus.d.ts

@@ -1,2 +1,2 @@
-import { Hocuspocus, Configuration } from '@hocuspocus/server';
-export declare const newHocuspocus: (options?: Partial<Configuration>) => Promise<Hocuspocus>;
+import type { ServerConfiguration } from '@hocuspocus/server';
+export declare const newHocuspocus: (options?: Partial<ServerConfiguration>) => Promise<import("@hocuspocus/server").Hocuspocus>;

package/dist/tests/utils/newHocuspocusProvider.d.ts

@@ -1,3 +1,3 @@
-import { HocuspocusProvider, HocuspocusProviderConfiguration, HocuspocusProviderWebsocketConfiguration } from '@hocuspocus/provider';
-import { Hocuspocus } from '@hocuspocus/server';
+import { HocuspocusProvider, type HocuspocusProviderConfiguration, type HocuspocusProviderWebsocketConfiguration } from '@hocuspocus/provider';
+import type { Hocuspocus } from '@hocuspocus/server';
 export declare const newHocuspocusProvider: (server: Hocuspocus, options?: Partial<HocuspocusProviderConfiguration>, websocketOptions?: Partial<HocuspocusProviderWebsocketConfiguration>) => HocuspocusProvider;

package/dist/tests/utils/newHocuspocusProviderWebsocket.d.ts

@@ -1,3 +1,4 @@
-import { HocuspocusProviderWebsocket, HocuspocusProviderWebsocketConfiguration } from '@hocuspocus/provider';
-import { Hocuspocus } from '@hocuspocus/server';
-export declare const newHocuspocusProviderWebsocket: (server: Hocuspocus, options?: Partial<Omit<HocuspocusProviderWebsocketConfiguration, 'url'>>) => HocuspocusProviderWebsocket;
+import type { HocuspocusProviderWebsocketConfiguration } from '@hocuspocus/provider';
+import { HocuspocusProviderWebsocket } from '@hocuspocus/provider';
+import type { Hocuspocus } from '@hocuspocus/server';
+export declare const newHocuspocusProviderWebsocket: (hocuspocus: Hocuspocus, options?: Partial<Omit<HocuspocusProviderWebsocketConfiguration, "url">>) => HocuspocusProviderWebsocket;

package/dist/tests/utils/retryableAssertion.d.ts

@@ -1,2 +1,2 @@
-import { ExecutionContext } from 'ava';
+import type { ExecutionContext } from 'ava';
 export declare const retryableAssertion: (t: ExecutionContext, recoverableTry: (tt: ExecutionContext) => void) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hocuspocus/provider",
-  "version": "2.13.5",
+  "version": "3.0.0-rc.0",
   "description": "hocuspocus provider",
   "homepage": "https://hocuspocus.dev",
   "keywords": [
@@ -29,7 +29,7 @@
     "dist"
   ],
   "dependencies": {
-    "@hocuspocus/common": "^2.13.5",
+    "@hocuspocus/common": "^3.0.0-rc.0",
     "@lifeomic/attempt": "^3.0.2",
     "lib0": "^0.2.87",
     "ws": "^8.17.1"

package/src/EventEmitter.ts

@@ -1,7 +1,8 @@
 export default class EventEmitter {
-
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
   public callbacks: { [key: string]: Function[] } = {}
 
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
   public on(event: string, fn: Function): this {
     if (!this.callbacks[event]) {
       this.callbacks[event] = []
@@ -22,6 +23,7 @@ export default class EventEmitter {
     return this
   }
 
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
   public off(event: string, fn?: Function): this {
     const callbacks = this.callbacks[event]
 

package/src/HocuspocusProvider.ts

@@ -1,12 +1,12 @@
 import { awarenessStatesToArray } from '@hocuspocus/common'
-import * as bc from 'lib0/broadcastchannel'
 import * as mutex from 'lib0/mutex'
 import type { CloseEvent, Event, MessageEvent } from 'ws'
 import { Awareness, removeAwarenessStates } from 'y-protocols/awareness'
 import * as Y from 'yjs'
 import EventEmitter from './EventEmitter.js'
+import type {
+  CompleteHocuspocusProviderWebsocketConfiguration} from './HocuspocusProviderWebsocket.js'
 import {
-  CompleteHocuspocusProviderWebsocketConfiguration,
   HocuspocusProviderWebsocket,
 } from './HocuspocusProviderWebsocket.js'
 import { IncomingMessage } from './IncomingMessage.js'
@@ -15,14 +15,11 @@ import { MessageSender } from './MessageSender.js'
 import { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage.js'
 import { AwarenessMessage } from './OutgoingMessages/AwarenessMessage.js'
 import { CloseMessage } from './OutgoingMessages/CloseMessage.js'
-import { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage.js'
 import { StatelessMessage } from './OutgoingMessages/StatelessMessage.js'
 import { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage.js'
-import { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage.js'
 import { UpdateMessage } from './OutgoingMessages/UpdateMessage.js'
-import {
+import type {
   ConstructableOutgoingMessage,
-  WebSocketStatus,
   onAuthenticationFailedParameters,
   onAwarenessChangeParameters,
   onAwarenessUpdateParameters,
@@ -153,7 +150,7 @@ export class HocuspocusProvider extends EventEmitter {
 
   unsyncedChanges = 0
 
-  status = WebSocketStatus.Disconnected
+  // status = WebSocketStatus.Disconnected
 
   isAuthenticated = false
 
@@ -165,7 +162,7 @@ export class HocuspocusProvider extends EventEmitter {
     forceSync: null,
   }
 
-  isConnected = true
+  // isConnected = true
 
   constructor(configuration: HocuspocusProviderConfiguration) {
     super()
@@ -196,7 +193,7 @@ export class HocuspocusProvider extends EventEmitter {
     this.configuration.websocketProvider.on('close', this.configuration.onClose)
     this.configuration.websocketProvider.on('close', this.forwardClose)
 
-    this.configuration.websocketProvider.on('status', this.boundOnStatus)
+    // this.configuration.websocketProvider.on('status', this.boundOnStatus)
 
     this.configuration.websocketProvider.on('disconnect', this.configuration.onDisconnect)
     this.configuration.websocketProvider.on('disconnect', this.forwardDisconnect)
@@ -229,7 +226,7 @@ export class HocuspocusProvider extends EventEmitter {
     this.configuration.websocketProvider.attach(this)
   }
 
-  boundBroadcastChannelSubscriber = this.broadcastChannelSubscriber.bind(this)
+  // boundBroadcastChannelSubscriber = this.broadcastChannelSubscriber.bind(this)
 
   boundPageHide = this.pageHide.bind(this)
 
@@ -237,7 +234,7 @@ export class HocuspocusProvider extends EventEmitter {
 
   boundOnClose = this.onClose.bind(this)
 
-  boundOnStatus = this.onStatus.bind(this)
+  // boundOnStatus = this.onStatus.bind(this)
 
   forwardConnect = (e: any) => this.emit('connect', e)
 
@@ -249,12 +246,12 @@ export class HocuspocusProvider extends EventEmitter {
 
   forwardDestroy = (e: any) => this.emit('destroy', e)
 
-  public onStatus({ status } : onStatusParameters) {
-    this.status = status
-
-    this.configuration.onStatus({ status })
-    this.emit('status', { status })
-  }
+  // public onStatus({ status } : onStatusParameters) {
+  //    this.status = status
+  //
+  //   this.configuration.onStatus({ status })
+  //   this.emit('status', { status })
+  // }
 
   public setConfiguration(configuration: Partial<HocuspocusProviderConfiguration> = {}): void {
     if (!configuration.websocketProvider && (configuration as CompleteHocuspocusProviderWebsocketConfiguration).url) {
@@ -373,29 +370,31 @@ export class HocuspocusProvider extends EventEmitter {
 
   // not needed, but provides backward compatibility with e.g. lexical/yjs
   async connect() {
-    if (this.configuration.broadcast) {
-      this.subscribeToBroadcastChannel()
-    }
-
-    this.configuration.websocketProvider.shouldConnect = true
+    console.warn('HocuspocusProvider::connect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.')
 
-    return this.configuration.websocketProvider.attach(this)
+    // if (this.configuration.broadcast) {
+    //   this.subscribeToBroadcastChannel()
+    // }
+    //
+    // return this.configuration.websocketProvider.connect()
   }
 
   disconnect() {
-    this.disconnectBroadcastChannel()
-    this.configuration.websocketProvider.detach(this)
-    this.isConnected = false
-
-    if (!this.configuration.preserveConnection) {
-      this.configuration.websocketProvider.disconnect()
-    }
+    console.warn('HocuspocusProvider::disconnect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.')
 
+    // this.disconnectBroadcastChannel()
+    // this.configuration.websocketProvider.detach(this)
+    // this.isConnected = false
+    //
+    // if (!this.configuration.preserveConnection) {
+    //   this.configuration.websocketProvider.disconnect()
+    // }
+    //
   }
 
   async onOpen(event: Event) {
     this.isAuthenticated = false
-    this.isConnected = true
+    // this.isConnected = true
 
     this.emit('open', { event })
 
@@ -441,13 +440,13 @@ export class HocuspocusProvider extends EventEmitter {
   }
 
   send(message: ConstructableOutgoingMessage, args: any, broadcast = false) {
-    if (!this.isConnected) {
-      return
-    }
+    // if (!this.isConnected) {
+    //   return
+    // }
 
-    if (broadcast) {
-      this.mux(() => { this.broadcast(message, args) })
-    }
+    // if (broadcast) {
+    //   this.mux(() => { this.broadcast(message, args) })
+    // }
 
     const messageSender = new MessageSender(message, args)
 
@@ -505,13 +504,14 @@ export class HocuspocusProvider extends EventEmitter {
     this.configuration.websocketProvider.off('close', this.boundOnClose)
     this.configuration.websocketProvider.off('close', this.configuration.onClose)
     this.configuration.websocketProvider.off('close', this.forwardClose)
-    this.configuration.websocketProvider.off('status', this.boundOnStatus)
+    // this.configuration.websocketProvider.off('status', this.boundOnStatus)
     this.configuration.websocketProvider.off('disconnect', this.configuration.onDisconnect)
     this.configuration.websocketProvider.off('disconnect', this.forwardDisconnect)
     this.configuration.websocketProvider.off('destroy', this.configuration.onDestroy)
     this.configuration.websocketProvider.off('destroy', this.forwardDestroy)
 
     this.send(CloseMessage, { documentName: this.configuration.name })
+    this.configuration.websocketProvider.detach(this)
     this.disconnect()
 
     if (typeof window === 'undefined' || !('removeEventListener' in window)) {
@@ -524,8 +524,8 @@ export class HocuspocusProvider extends EventEmitter {
   permissionDeniedHandler(reason: string) {
     this.emit('authenticationFailed', { reason })
     this.isAuthenticated = false
-    this.disconnect()
-    this.status = WebSocketStatus.Disconnected
+    // this.disconnect()
+    // this.status = WebSocketStatus.Disconnected
   }
 
   authenticatedHandler(scope: string) {
@@ -535,73 +535,73 @@ export class HocuspocusProvider extends EventEmitter {
     this.emit('authenticated')
   }
 
-  get broadcastChannel() {
-    return `${this.configuration.name}`
-  }
-
-  broadcastChannelSubscriber(data: ArrayBuffer) {
-    this.mux(() => {
-      const message = new IncomingMessage(data)
-
-      const documentName = message.readVarString()
-
-      message.writeVarString(documentName)
-
-      new MessageReceiver(message)
-        .setBroadcasted(true)
-        .apply(this, false)
-    })
-  }
-
-  subscribeToBroadcastChannel() {
-    if (!this.subscribedToBroadcastChannel) {
-      bc.subscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber)
-      this.subscribedToBroadcastChannel = true
-    }
-
-    this.mux(() => {
-      this.broadcast(SyncStepOneMessage, { document: this.document, documentName: this.configuration.name })
-      this.broadcast(SyncStepTwoMessage, { document: this.document, documentName: this.configuration.name })
-      this.broadcast(QueryAwarenessMessage, { document: this.document, documentName: this.configuration.name })
-      if (this.awareness) {
-        this.broadcast(AwarenessMessage, {
-          awareness: this.awareness,
-          clients: [this.document.clientID],
-          document: this.document,
-          documentName: this.configuration.name,
-        })
-      }
-    })
-  }
-
-  disconnectBroadcastChannel() {
-    // broadcast message with local awareness state set to null (indicating disconnect)
-    if (this.awareness) {
-      this.send(AwarenessMessage, {
-        awareness: this.awareness,
-        clients: [this.document.clientID],
-        states: new Map(),
-        documentName: this.configuration.name,
-      }, true)
-    }
-
-    if (this.subscribedToBroadcastChannel) {
-      bc.unsubscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber)
-      this.subscribedToBroadcastChannel = false
-    }
-  }
-
-  broadcast(Message: ConstructableOutgoingMessage, args?: any) {
-    if (!this.configuration.broadcast) {
-      return
-    }
-
-    if (!this.subscribedToBroadcastChannel) {
-      return
-    }
-
-    new MessageSender(Message, args).broadcast(this.broadcastChannel)
-  }
+  // get broadcastChannel() {
+  //   return `${this.configuration.name}`
+  // }
+  //
+  // broadcastChannelSubscriber(data: ArrayBuffer) {
+  //   this.mux(() => {
+  //     const message = new IncomingMessage(data)
+  //
+  //     const documentName = message.readVarString()
+  //
+  //     message.writeVarString(documentName)
+  //
+  //     new MessageReceiver(message)
+  //       .setBroadcasted(true)
+  //       .apply(this, false)
+  //   })
+  // }
+
+  // subscribeToBroadcastChannel() {
+  //   if (!this.subscribedToBroadcastChannel) {
+  //     bc.subscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber)
+  //     this.subscribedToBroadcastChannel = true
+  //   }
+  //
+  //   this.mux(() => {
+  //     this.broadcast(SyncStepOneMessage, { document: this.document, documentName: this.configuration.name })
+  //     this.broadcast(SyncStepTwoMessage, { document: this.document, documentName: this.configuration.name })
+  //     this.broadcast(QueryAwarenessMessage, { document: this.document, documentName: this.configuration.name })
+  //     if (this.awareness) {
+  //       this.broadcast(AwarenessMessage, {
+  //         awareness: this.awareness,
+  //         clients: [this.document.clientID],
+  //         document: this.document,
+  //         documentName: this.configuration.name,
+  //       })
+  //     }
+  //   })
+  // }
+  //
+  // disconnectBroadcastChannel() {
+  //   // broadcast message with local awareness state set to null (indicating disconnect)
+  //   if (this.awareness) {
+  //     this.send(AwarenessMessage, {
+  //       awareness: this.awareness,
+  //       clients: [this.document.clientID],
+  //       states: new Map(),
+  //       documentName: this.configuration.name,
+  //     }, true)
+  //   }
+  //
+  //   if (this.subscribedToBroadcastChannel) {
+  //     bc.unsubscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber)
+  //     this.subscribedToBroadcastChannel = false
+  //   }
+  // }
+
+  // broadcast(Message: ConstructableOutgoingMessage, args?: any) {
+  //   if (!this.configuration.broadcast) {
+  //     return
+  //   }
+  //
+  //   if (!this.subscribedToBroadcastChannel) {
+  //     return
+  //   }
+  //
+  //   new MessageSender(Message, args).broadcast(this.broadcastChannel)
+  // }
 
   setAwarenessField(key: string, value: any) {
     if (!this.awareness) {

package/src/HocuspocusProviderWebsocket.ts

@@ -4,14 +4,14 @@ import {
 import { retry } from '@lifeomic/attempt'
 import * as time from 'lib0/time'
 import * as url from 'lib0/url'
-import type { MessageEvent } from 'ws'
-import { Event } from 'ws'
+import type { MessageEvent , Event } from 'ws'
 import EventEmitter from './EventEmitter.js'
-import { HocuspocusProvider } from './HocuspocusProvider.js'
+import type { HocuspocusProvider } from './HocuspocusProvider.js'
+import type {
+  onAwarenessChangeParameters, onAwarenessUpdateParameters,
+  onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters} from './types.js'
 import {
   WebSocketStatus,
-  onAwarenessChangeParameters, onAwarenessUpdateParameters,
-  onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters,
 } from './types.js'
 import { IncomingMessage } from './IncomingMessage.js'
 
@@ -228,11 +228,9 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
       provider.onOpen(this.receivedOnOpenPayload)
     }
 
-    if (this.receivedOnStatusPayload) {
-      provider.onStatus(this.receivedOnStatusPayload)
-    }
-
-    return connectPromise
+    // if (this.receivedOnStatusPayload) {
+    //   provider.onStatus(this.receivedOnStatusPayload)
+    // }
   }
 
   detach(provider: HocuspocusProvider) {
@@ -301,6 +299,7 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
     return retryPromise
   }
 
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
   attachWebSocketListeners(ws: HocusPocusWebSocket, reject: Function) {
     const { identifier } = ws
     const onMessageHandler = (payload: any) => this.emit('message', payload)

package/src/IncomingMessage.ts

@@ -1,20 +1,22 @@
+import type {
+  Decoder} from 'lib0/decoding'
 import {
   createDecoder,
   peekVarString,
   readVarUint,
   readVarUint8Array,
   readVarString,
-  Decoder,
 } from 'lib0/decoding'
+import type {
+  Encoder} from 'lib0/encoding'
 import {
-  Encoder,
   createEncoder,
   writeVarUint,
   writeVarUint8Array,
   writeVarString,
   length,
 } from 'lib0/encoding'
-import { MessageType } from './types.js'
+import type { MessageType } from './types.js'
 
 export class IncomingMessage {
 

package/src/MessageReceiver.ts

@@ -2,8 +2,8 @@ import { readAuthMessage } from '@hocuspocus/common'
 import { readVarInt, readVarString } from 'lib0/decoding'
 import * as awarenessProtocol from 'y-protocols/awareness'
 import { messageYjsSyncStep2, readSyncMessage } from 'y-protocols/sync'
-import { HocuspocusProvider } from './HocuspocusProvider.js'
-import { IncomingMessage } from './IncomingMessage.js'
+import type { HocuspocusProvider } from './HocuspocusProvider.js'
+import type { IncomingMessage } from './IncomingMessage.js'
 import { OutgoingMessage } from './OutgoingMessage.js'
 import { MessageType } from './types.js'
 

package/src/MessageSender.ts

@@ -1,6 +1,7 @@
-import { Encoder, toUint8Array } from 'lib0/encoding'
+import type { Encoder} from 'lib0/encoding'
+import { toUint8Array } from 'lib0/encoding'
 import * as bc from 'lib0/broadcastchannel'
-import { ConstructableOutgoingMessage } from './types.js'
+import type { ConstructableOutgoingMessage } from './types.js'
 
 export class MessageSender {
 

package/src/OutgoingMessage.ts

@@ -1,5 +1,6 @@
-import { Encoder, createEncoder, toUint8Array } from 'lib0/encoding'
-import { MessageType, OutgoingMessageArguments, OutgoingMessageInterface } from './types.js'
+import type { Encoder} from 'lib0/encoding'
+import { createEncoder, toUint8Array } from 'lib0/encoding'
+import type { MessageType, OutgoingMessageArguments, OutgoingMessageInterface } from './types.js'
 
 export class OutgoingMessage implements OutgoingMessageInterface {
   encoder: Encoder

package/src/OutgoingMessages/AuthenticationMessage.ts

@@ -1,6 +1,7 @@
 import { writeVarString, writeVarUint } from 'lib0/encoding'
 import { writeAuthentication } from '@hocuspocus/common'
-import { MessageType, OutgoingMessageArguments } from '../types.js'
+import type { OutgoingMessageArguments } from '../types.js'
+import { MessageType } from '../types.js'
 import { OutgoingMessage } from '../OutgoingMessage.js'
 
 export class AuthenticationMessage extends OutgoingMessage {

package/src/OutgoingMessages/AwarenessMessage.ts

@@ -1,6 +1,7 @@
 import * as encoding from 'lib0/encoding'
 import { encodeAwarenessUpdate } from 'y-protocols/awareness'
-import { MessageType, OutgoingMessageArguments } from '../types.js'
+import type { OutgoingMessageArguments } from '../types.js'
+import { MessageType } from '../types.js'
 import { OutgoingMessage } from '../OutgoingMessage.js'
 
 export class AwarenessMessage extends OutgoingMessage {

package/src/OutgoingMessages/CloseMessage.ts

@@ -1,5 +1,6 @@
 import * as encoding from 'lib0/encoding'
-import { MessageType, OutgoingMessageArguments } from '../types.js'
+import type { OutgoingMessageArguments } from '../types.js'
+import { MessageType } from '../types.js'
 import { OutgoingMessage } from '../OutgoingMessage.js'
 
 export class CloseMessage extends OutgoingMessage {

package/src/OutgoingMessages/QueryAwarenessMessage.ts

@@ -1,5 +1,6 @@
 import * as encoding from 'lib0/encoding'
-import { MessageType, OutgoingMessageArguments } from '../types.js'
+import type { OutgoingMessageArguments } from '../types.js'
+import { MessageType } from '../types.js'
 import { OutgoingMessage } from '../OutgoingMessage.js'
 
 export class QueryAwarenessMessage extends OutgoingMessage {

package/src/OutgoingMessages/StatelessMessage.ts

@@ -1,5 +1,6 @@
 import { writeVarString, writeVarUint } from 'lib0/encoding'
-import { MessageType, OutgoingMessageArguments } from '../types.js'
+import type { OutgoingMessageArguments } from '../types.js'
+import { MessageType } from '../types.js'
 import { OutgoingMessage } from '../OutgoingMessage.js'
 
 export class StatelessMessage extends OutgoingMessage {

package/src/OutgoingMessages/SyncStepOneMessage.ts

@@ -1,6 +1,7 @@
 import * as encoding from 'lib0/encoding'
 import * as syncProtocol from 'y-protocols/sync'
-import { MessageType, OutgoingMessageArguments } from '../types.js'
+import type { OutgoingMessageArguments } from '../types.js'
+import { MessageType } from '../types.js'
 import { OutgoingMessage } from '../OutgoingMessage.js'
 
 export class SyncStepOneMessage extends OutgoingMessage {

package/src/OutgoingMessages/SyncStepTwoMessage.ts

@@ -1,6 +1,7 @@
 import * as encoding from 'lib0/encoding'
 import * as syncProtocol from 'y-protocols/sync'
-import { MessageType, OutgoingMessageArguments } from '../types.js'
+import type { OutgoingMessageArguments } from '../types.js'
+import { MessageType } from '../types.js'
 import { OutgoingMessage } from '../OutgoingMessage.js'
 
 export class SyncStepTwoMessage extends OutgoingMessage {

package/src/OutgoingMessages/UpdateMessage.ts

@@ -1,6 +1,7 @@
 import { writeVarString, writeVarUint } from 'lib0/encoding'
 import { writeUpdate } from 'y-protocols/sync'
-import { MessageType, OutgoingMessageArguments } from '../types.js'
+import type { OutgoingMessageArguments } from '../types.js'
+import { MessageType } from '../types.js'
 import { OutgoingMessage } from '../OutgoingMessage.js'
 
 export class UpdateMessage extends OutgoingMessage {

package/src/TiptapCollabProvider.ts

@@ -1,9 +1,10 @@
 import type { AbstractType, YArrayEvent } from 'yjs'
 import * as Y from 'yjs'
 import { uuidv4 } from 'lib0/random'
+import type {
+  HocuspocusProviderConfiguration} from './HocuspocusProvider.js'
 import {
   HocuspocusProvider,
-  HocuspocusProviderConfiguration,
 } from './HocuspocusProvider.js'
 
 import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.js'

package/src/TiptapCollabProviderWebsocket.ts

@@ -1,6 +1,7 @@
+import type {
+  CompleteHocuspocusProviderWebsocketConfiguration, HocuspocusProviderWebsocketConfiguration} from './HocuspocusProviderWebsocket.js'
 import {
-  CompleteHocuspocusProviderWebsocketConfiguration,
-  HocuspocusProviderWebsocket, HocuspocusProviderWebsocketConfiguration,
+  HocuspocusProviderWebsocket,
 } from './HocuspocusProviderWebsocket.js'
 
 export type TiptapCollabProviderWebsocketConfiguration =

package/src/types.ts

@@ -1,16 +1,16 @@
-import { Encoder } from 'lib0/encoding'
+import type { Encoder } from 'lib0/encoding'
 import type { Event, MessageEvent } from 'ws'
-import { Awareness } from 'y-protocols/awareness'
-import * as Y from 'yjs'
-import { CloseEvent } from '@hocuspocus/common'
-import { IncomingMessage } from './IncomingMessage.js'
-import { OutgoingMessage } from './OutgoingMessage.js'
-import { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage.js'
-import { AwarenessMessage } from './OutgoingMessages/AwarenessMessage.js'
-import { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage.js'
-import { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage.js'
-import { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage.js'
-import { UpdateMessage } from './OutgoingMessages/UpdateMessage.js'
+import type { Awareness } from 'y-protocols/awareness'
+import type * as Y from 'yjs'
+import type { CloseEvent } from '@hocuspocus/common'
+import type { IncomingMessage } from './IncomingMessage.js'
+import type { OutgoingMessage } from './OutgoingMessage.js'
+import type { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage.js'
+import type { AwarenessMessage } from './OutgoingMessages/AwarenessMessage.js'
+import type { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage.js'
+import type { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage.js'
+import type { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage.js'
+import type { UpdateMessage } from './OutgoingMessages/UpdateMessage.js'
 
 export enum MessageType {
   Sync = 0,