@hocuspocus/provider 3.0.0-rc.0 → 3.0.6-rc.0

package/src/HocuspocusProviderWebsocket.ts

@@ -1,19 +1,20 @@
 import {
-  Forbidden, MessageTooBig, Unauthorized, WsReadyStates,
+  WsReadyStates,
 } from '@hocuspocus/common'
 import { retry } from '@lifeomic/attempt'
 import * as time from 'lib0/time'
 import * as url from 'lib0/url'
 import type { MessageEvent , Event } from 'ws'
-import EventEmitter from './EventEmitter.js'
-import type { HocuspocusProvider } from './HocuspocusProvider.js'
+import EventEmitter from './EventEmitter.ts'
+import type { HocuspocusProvider } from './HocuspocusProvider.ts'
 import type {
   onAwarenessChangeParameters, onAwarenessUpdateParameters,
-  onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters} from './types.js'
+  onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters} from './types.ts'
 import {
   WebSocketStatus,
-} from './types.js'
-import { IncomingMessage } from './IncomingMessage.js'
+} from './types.ts'
+import { IncomingMessage } from './IncomingMessage.ts'
+import { CloseMessage } from "./OutgoingMessages/CloseMessage.ts"
 
 export type HocusPocusWebSocket = WebSocket & { identifier: string };
 
@@ -87,10 +88,6 @@ export interface CompleteHocuspocusProviderWebsocketConfiguration {
   onDestroy: () => void,
   onAwarenessUpdate: (data: onAwarenessUpdateParameters) => void,
   onAwarenessChange: (data: onAwarenessChangeParameters) => void,
-  /**
-   * Don’t output any warnings.
-   */
-  quiet: boolean,
 
   /**
    * Map of attached providers keyed by documentName.
@@ -138,7 +135,6 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
     onDestroy: () => null,
     onAwarenessUpdate: () => null,
     onAwarenessChange: () => null,
-    quiet: false,
     providerMap: new Map(),
   }
 
@@ -155,7 +151,6 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
   identifier = 0
 
   intervals: any = {
-    forceSync: null,
     connectionChecker: null,
   }
 
@@ -209,6 +204,7 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
   receivedOnStatusPayload?: onStatusParameters | undefined = undefined
 
   async onOpen(event: Event) {
+    this.cancelWebsocketRetry = undefined
     this.receivedOnOpenPayload = event
   }
 
@@ -227,14 +223,13 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
     if (this.receivedOnOpenPayload) {
       provider.onOpen(this.receivedOnOpenPayload)
     }
-
-    // if (this.receivedOnStatusPayload) {
-    //   provider.onStatus(this.receivedOnStatusPayload)
-    // }
   }
 
   detach(provider: HocuspocusProvider) {
-    this.configuration.providerMap.delete(provider.configuration.name)
+    if( this.configuration.providerMap.has(provider.configuration.name )) {
+      provider.send(CloseMessage, { documentName: provider.configuration.name })
+      this.configuration.providerMap.delete(provider.configuration.name)
+    }
   }
 
   public setConfiguration(
@@ -441,7 +436,7 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
     }
   }
 
-  // Ensure that the URL always ends with /
+  // Ensure that the URL never ends with /
   get serverUrl() {
     while (this.configuration.url[this.configuration.url.length - 1] === '/') {
       return this.configuration.url.slice(0, this.configuration.url.length - 1)
@@ -466,8 +461,8 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
     try {
       this.webSocket.close()
       this.messageQueue = []
-    } catch {
-      //
+    } catch(e) {
+      console.error(e)
     }
   }
 
@@ -483,73 +478,28 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
     this.closeTries = 0
     this.cleanupWebSocket()
 
-    if (this.status === WebSocketStatus.Connected) {
-      this.status = WebSocketStatus.Disconnected
-      this.emit('status', { status: WebSocketStatus.Disconnected })
-      this.emit('disconnect', { event })
-    }
-
-    if (event.code === Unauthorized.code) {
-      if (event.reason === Unauthorized.reason) {
-        console.warn(
-          '[HocuspocusProvider] An authentication token is required, but you didn’t send one. Try adding a `token` to your HocuspocusProvider configuration. Won’t try again.',
-        )
-      } else {
-        console.warn(
-          `[HocuspocusProvider] Connection closed with status Unauthorized: ${event.reason}`,
-        )
-      }
-
-      this.shouldConnect = false
-    }
-
-    if (event.code === Forbidden.code) {
-      if (!this.configuration.quiet) {
-        console.warn(
-          '[HocuspocusProvider] The provided authentication token isn’t allowed to connect to this server. Will try again.',
-        )
-        return // TODO REMOVE ME
-      }
-    }
-
-    if (event.code === MessageTooBig.code) {
-      console.warn(
-        `[HocuspocusProvider] Connection closed with status MessageTooBig: ${event.reason}`,
-      )
-      this.shouldConnect = false
-    }
-
     if (this.connectionAttempt) {
       // That connection attempt failed.
       this.rejectConnectionAttempt()
-    } else if (this.shouldConnect) {
-      // The connection was closed by the server. Let’s just try again.
-      this.connect()
-    }
-
-    // If we’ll reconnect, we’re done for now.
-    if (this.shouldConnect) {
-      return
-    }
-
-    // The status is set correctly already.
-    if (this.status === WebSocketStatus.Disconnected) {
-      return
     }
 
     // Let’s update the connection status.
     this.status = WebSocketStatus.Disconnected
     this.emit('status', { status: WebSocketStatus.Disconnected })
     this.emit('disconnect', { event })
+
+    // trigger connect if no retry is running and we want to have a connection
+    if( !this.cancelWebsocketRetry && this.shouldConnect ) {
+
+      setTimeout(() => {
+        this.connect()
+      }, this.configuration.delay)
+    }
   }
 
   destroy() {
     this.emit('destroy')
 
-    if (this.intervals.forceSync) {
-      clearInterval(this.intervals.forceSync)
-    }
-
     clearInterval(this.intervals.connectionChecker)
 
     // If there is still a connection attempt outstanding then we should stop

package/src/IncomingMessage.ts

@@ -16,7 +16,7 @@ import {
   writeVarString,
   length,
 } from 'lib0/encoding'
-import type { MessageType } from './types.js'
+import type { MessageType } from './types.ts'
 
 export class IncomingMessage {
 

package/src/MessageReceiver.ts

@@ -2,27 +2,20 @@ 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 type { HocuspocusProvider } from './HocuspocusProvider.js'
-import type { IncomingMessage } from './IncomingMessage.js'
-import { OutgoingMessage } from './OutgoingMessage.js'
-import { MessageType } from './types.js'
+import type { CloseEvent } from 'ws'
+import type { HocuspocusProvider } from './HocuspocusProvider.ts'
+import type { IncomingMessage } from './IncomingMessage.ts'
+import { OutgoingMessage } from './OutgoingMessage.ts'
+import { MessageType } from './types.ts'
 
 export class MessageReceiver {
 
   message: IncomingMessage
 
-  broadcasted = false
-
   constructor(message: IncomingMessage) {
     this.message = message
   }
 
-  public setBroadcasted(value: boolean) {
-    this.broadcasted = value
-
-    return this
-  }
-
   public apply(provider: HocuspocusProvider, emitSynced: boolean) {
     const { message } = this
     const type = message.readVarUint()
@@ -53,21 +46,29 @@ export class MessageReceiver {
       case MessageType.SyncStatus:
         this.applySyncStatusMessage(provider, readVarInt(message.decoder) === 1)
         break
+
+      case MessageType.CLOSE:
+        // eslint-disable-next-line no-case-declarations
+        const event: CloseEvent = {
+          code: 1000,
+          reason: readVarString(message.decoder),
+          // @ts-ignore
+          target: provider.configuration.websocketProvider.webSocket!,
+          type: 'close',
+        }
+        provider.onClose()
+        provider.configuration.onClose({ event })
+        provider.forwardClose(event)
+      break
+
       default:
         throw new Error(`Can’t apply message of unknown type: ${type}`)
     }
 
     // Reply
     if (message.length() > emptyMessageLength + 1) { // length of documentName (considered in emptyMessageLength plus length of yjs sync type, set in applySyncMessage)
-      if (this.broadcasted) {
-        // TODO: Some weird TypeScript error
-        // @ts-ignore
-        provider.broadcast(OutgoingMessage, { encoder: message.encoder })
-      } else {
-        // TODO: Some weird TypeScript error
-        // @ts-ignore
-        provider.send(OutgoingMessage, { encoder: message.encoder })
-      }
+      // @ts-ignore
+      provider.send(OutgoingMessage, { encoder: message.encoder })
     }
   }
 

package/src/MessageSender.ts

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

package/src/OutgoingMessage.ts

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

package/src/OutgoingMessages/AuthenticationMessage.ts

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

package/src/OutgoingMessages/AwarenessMessage.ts

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

package/src/OutgoingMessages/CloseMessage.ts

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

package/src/OutgoingMessages/QueryAwarenessMessage.ts

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

package/src/OutgoingMessages/StatelessMessage.ts

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

package/src/OutgoingMessages/SyncStepOneMessage.ts

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

package/src/OutgoingMessages/SyncStepTwoMessage.ts

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

package/src/OutgoingMessages/UpdateMessage.ts

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

package/src/index.ts

@@ -1,5 +1,3 @@
-export * from './HocuspocusProvider.js'
-export * from './TiptapCollabProvider.js'
-export * from './TiptapCollabProviderWebsocket.js'
-export * from './HocuspocusProviderWebsocket.js'
-export * from './types.js'
+export * from './HocuspocusProvider.ts'
+export * from './HocuspocusProviderWebsocket.ts'
+export * from './types.ts'

package/src/types.ts

@@ -3,14 +3,14 @@ import type { Event, MessageEvent } from 'ws'
 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'
+import type { IncomingMessage } from './IncomingMessage.ts'
+import type { OutgoingMessage } from './OutgoingMessage.ts'
+import type { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage.ts'
+import type { AwarenessMessage } from './OutgoingMessages/AwarenessMessage.ts'
+import type { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage.ts'
+import type { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage.ts'
+import type { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage.ts'
+import type { UpdateMessage } from './OutgoingMessages/UpdateMessage.ts'
 
 export enum MessageType {
   Sync = 0,
@@ -110,15 +110,18 @@ export type TCollabThread<Data = any, CommentData = any> = {
   id: string;
   createdAt: number;
   updatedAt: number;
+  deletedAt: number | null;
   resolvedAt?: string; // (new Date()).toISOString()
   comments: TCollabComment<CommentData>[];
+  deletedComments: TCollabComment<CommentData>[];
   data: Data
 }
 
 export type TCollabComment<Data = any> = {
   id: string;
-  createdAt: number;
-  updatedAt: number;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt?: string;
   data: Data
   content: any
 }
@@ -183,3 +186,46 @@ export type THistoryDocumentRevertedEvent = {
   event: 'document.reverted';
   version: number;
 };
+
+export type DeleteCommentOptions = {
+  /**
+   * If `true`, the thread will also be deleted if the deleted comment was the first comment in the thread.
+   */
+  deleteThread?: boolean
+
+  /**
+   * If `true`, will remove the content of the deleted comment
+   */
+  deleteContent?: boolean
+}
+
+export type DeleteThreadOptions = {
+  /**
+   * If `true`, will remove the comments on the thread,
+   * otherwise will only mark the thread as deleted
+   * and keep the comments
+   * @default false
+   */
+  deleteComments?: boolean
+
+  /**
+   * If `true`, will forcefully remove the thread and all comments,
+   * otherwise will only mark the thread as deleted
+   * and keep the comments
+   * @default false
+   */
+  force?: boolean,
+}
+
+/**
+ * The type of thread
+ */
+export type ThreadType = 'archived' | 'unarchived'
+
+export type GetThreadsOptions = {
+  /**
+   * The types of threads to get
+   * @default ['unarchived']
+   */
+  types?: Array<ThreadType>
+}

package/dist/packages/provider/src/TiptapCollabProvider.d.ts

@@ -1,64 +0,0 @@
-import type { AbstractType, YArrayEvent } from 'yjs';
-import * as Y from 'yjs';
-import type { HocuspocusProviderConfiguration } from './HocuspocusProvider.js';
-import { HocuspocusProvider } from './HocuspocusProvider.js';
-import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.js';
-import type { TCollabComment, TCollabThread, THistoryVersion } from './types.js';
-export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & (Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'websocketProvider'>> | Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'appId'>> | Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'baseUrl'>>) & Pick<AdditionalTiptapCollabProviderConfiguration, 'user'>;
-export interface AdditionalTiptapCollabProviderConfiguration {
-    /**
-     * A Hocuspocus Cloud App ID, get one here: https://cloud.tiptap.dev
-     */
-    appId?: string;
-    /**
-     * If you are using the on-premise version of TiptapCollab, put your baseUrl here (e.g. https://collab.yourdomain.com)
-     */
-    baseUrl?: string;
-    websocketProvider?: TiptapCollabProviderWebsocket;
-    user?: string;
-}
-export declare class TiptapCollabProvider extends HocuspocusProvider {
-    tiptapCollabConfigurationPrefix: string;
-    userData?: Y.PermanentUserData;
-    constructor(configuration: TiptapCollabProviderConfiguration);
-    /**
-     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
-     */
-    createVersion(name?: string): void;
-    /**
-     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
-     */
-    revertToVersion(targetVersion: number): void;
-    /**
-     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
-     *
-     * The server will reply with a stateless message (THistoryVersionPreviewEvent)
-     */
-    previewVersion(targetVersion: number): void;
-    /**
-     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
-     */
-    getVersions(): THistoryVersion[];
-    watchVersions(callback: Parameters<AbstractType<YArrayEvent<THistoryVersion>>['observe']>[0]): void;
-    unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<THistoryVersion>>['unobserve']>[0]): void;
-    isAutoVersioning(): boolean;
-    enableAutoVersioning(): 1;
-    disableAutoVersioning(): 0;
-    private getYThreads;
-    getThreads<Data, CommentData>(): TCollabThread<Data, CommentData>[];
-    private getThreadIndex;
-    getThread<Data, CommentData>(id: string): TCollabThread<Data, CommentData> | null;
-    private getYThread;
-    createThread(data: Omit<TCollabThread, 'id' | 'createdAt' | 'updatedAt' | 'comments'>): TCollabThread;
-    updateThread(id: TCollabThread['id'], data: Partial<Pick<TCollabThread, 'data'> & {
-        resolvedAt: TCollabThread['resolvedAt'] | null;
-    }>): TCollabThread;
-    deleteThread(id: TCollabThread['id']): void;
-    getThreadComments(threadId: TCollabThread['id']): TCollabComment[] | null;
-    getThreadComment(threadId: TCollabThread['id'], commentId: TCollabComment['id']): TCollabComment | null;
-    addComment(threadId: TCollabThread['id'], data: Omit<TCollabComment, 'id' | 'updatedAt' | 'createdAt'>): TCollabThread;
-    updateComment(threadId: TCollabThread['id'], commentId: TCollabComment['id'], data: Partial<Pick<TCollabComment, 'data' | 'content'>>): TCollabThread;
-    deleteComment(threadId: TCollabThread['id'], commentId: TCollabComment['id']): TCollabThread | null | undefined;
-    watchThreads(callback: () => void): void;
-    unwatchThreads(callback: () => void): void;
-}

package/dist/packages/provider/src/TiptapCollabProviderWebsocket.d.ts

@@ -1,20 +0,0 @@
-import type { CompleteHocuspocusProviderWebsocketConfiguration } from './HocuspocusProviderWebsocket.js';
-import { HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket.js';
-export type TiptapCollabProviderWebsocketConfiguration = Partial<CompleteHocuspocusProviderWebsocketConfiguration> & AdditionalTiptapCollabProviderWebsocketConfiguration;
-export interface AdditionalTiptapCollabProviderWebsocketConfiguration {
-    /**
-     * A Hocuspocus Cloud App ID, get one here: https://cloud.tiptap.dev
-     */
-    appId?: string;
-    /**
-     * If you are using the on-premise version of TiptapCollab, put your baseUrl here (e.g. https://collab.yourdomain.com)
-     */
-    baseUrl?: string;
-    /**
-     * Only fill this if you are using Tiptap Collab HA.
-     */
-    shardKey?: string;
-}
-export declare class TiptapCollabProviderWebsocket extends HocuspocusProviderWebsocket {
-    constructor(configuration: TiptapCollabProviderWebsocketConfiguration);
-}

package/dist/packages/server/src/Debugger.d.ts

@@ -1,14 +0,0 @@
-export declare class Debugger {
-    logs: any[];
-    listen: boolean;
-    output: boolean;
-    enable(): void;
-    disable(): void;
-    verbose(): void;
-    quiet(): void;
-    log(message: any): this;
-    flush(): this;
-    get(): {
-        logs: any[];
-    };
-}

package/dist/playground/frontend/vite.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vite").UserConfig;
-export default _default;

package/dist/tests/server/getMessageLogs.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/server/requiresAuthentication.d.ts

@@ -1 +0,0 @@
-export {};