@abraca/dabra 0.6.0 → 0.8.0

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { Event, MessageEvent } from "ws";
 import * as Y from "yjs";
-import { CloseEvent } from "@abraca/dabra-common";
 
 //#region node_modules/lib0/observable.d.ts
 /**
@@ -132,6 +131,42 @@ declare class EventEmitter {
   removeAllListeners(): void;
 }
 //#endregion
+//#region packages/provider/src/DocumentCache.d.ts
+interface DocumentCacheOptions {
+  /** How long cached entries remain valid. Default: 5 minutes. */
+  ttlMs?: number;
+}
+declare class DocumentCache {
+  private readonly origin;
+  private readonly ttlMs;
+  private dbPromise;
+  private db;
+  constructor(serverOrigin: string, opts?: DocumentCacheOptions);
+  private getDb;
+  private isExpired;
+  private getWithTtl;
+  private setWithTtl;
+  private deleteKey;
+  getDoc(docId: string): Promise<DocumentMeta | null>;
+  setDoc(meta: DocumentMeta): Promise<void>;
+  invalidateDoc(docId: string): Promise<void>;
+  getChildren(parentId: string): Promise<string[] | null>;
+  setChildren(parentId: string, items: string[]): Promise<void>;
+  invalidateChildren(parentId: string): Promise<void>;
+  getProfile(userId: string): Promise<UserProfile | null>;
+  setProfile(profile: UserProfile): Promise<void>;
+  /** Get the cached profile for the currently authenticated user. */
+  getCurrentProfile(): Promise<UserProfile | null>;
+  /** Cache a profile both by its ID and as the current user. */
+  setCurrentProfile(profile: UserProfile): Promise<void>;
+  getPermissions(docId: string): Promise<PermissionEntry[] | null>;
+  setPermissions(docId: string, items: PermissionEntry[]): Promise<void>;
+  getUploads(docId: string): Promise<UploadInfo[] | null>;
+  setUploads(docId: string, items: UploadInfo[]): Promise<void>;
+  invalidateUploads(docId: string): Promise<void>;
+  destroy(): void;
+}
+//#endregion
 //#region packages/provider/src/AbracadabraClient.d.ts
 interface AbracadabraClientConfig {
   /** Server base URL (http or https). WebSocket URL is derived automatically. */
@@ -144,6 +179,13 @@ interface AbracadabraClientConfig {
   storageKey?: string;
   /** Custom fetch implementation (useful for Node.js or testing). */
   fetch?: typeof globalThis.fetch;
+  /**
+   * Optional metadata cache. When provided, read methods (getDoc, listChildren,
+   * getMe, listPermissions, listUploads) check the cache before hitting the
+   * network. Write methods (deleteDoc, upload, deleteUpload) invalidate affected
+   * cache entries automatically.
+   */
+  cache?: DocumentCache;
 }
 declare class AbracadabraClient {
   private _token;
@@ -151,6 +193,7 @@ declare class AbracadabraClient {
   private readonly persistAuth;
   private readonly storageKey;
   private readonly _fetch;
+  readonly cache: DocumentCache | null;
   constructor(config: AbracadabraClientConfig);
   get token(): string | null;
   set token(value: string | null);
@@ -163,6 +206,7 @@ declare class AbracadabraClient {
     password: string;
     email?: string;
     displayName?: string;
+    inviteCode?: string;
   }): Promise<UserProfile>;
   /**
    * Register a new user with an Ed25519 public key (crypto auth).
@@ -174,6 +218,7 @@ declare class AbracadabraClient {
     deviceName?: string;
     displayName?: string;
     email?: string;
+    inviteCode?: string;
   }): Promise<UserProfile>;
   /** Login with username + password. Auto-persists returned token. */
   login(opts: {
@@ -246,8 +291,25 @@ declare class AbracadabraClient {
   getUpload(docId: string, uploadId: string): Promise<Blob>;
   /** Delete an upload (requires uploader or document Owner). */
   deleteUpload(docId: string, uploadId: string): Promise<void>;
+  /** Create an invite code (requires permission per server config). */
+  createInvite(opts?: {
+    role?: string;
+    maxUses?: number;
+    expiresIn?: number;
+  }): Promise<InviteRow>;
+  /** List invite codes visible to the current user. */
+  listInvites(): Promise<InviteRow[]>;
+  /** Revoke an invite by its code. */
+  revokeInvite(code: string): Promise<void>;
+  /** Redeem an invite code for the currently authenticated user. */
+  redeemInvite(code: string): Promise<void>;
   /** Health check — no auth required. */
   health(): Promise<HealthStatus>;
+  /**
+   * Fetch server metadata including the optional `index_doc_id` entry point.
+   * No auth required.
+   */
+  serverInfo(): Promise<ServerInfo>;
   private request;
   private toError;
   private loadPersistedToken;
@@ -256,7 +318,7 @@ declare class AbracadabraClient {
 }
 //#endregion
 //#region packages/provider/src/AbracadabraProvider.d.ts
-interface AbracadabraProviderConfiguration extends Omit<HocuspocusProviderConfiguration, "url" | "websocketProvider"> {
+interface AbracadabraProviderConfiguration extends Omit<AbracadabraBaseProviderConfiguration, "url" | "websocketProvider"> {
   /**
    * Subdocument loading strategy.
    * - "lazy"  (default) – child providers are created only when explicitly requested.
@@ -291,10 +353,10 @@ interface AbracadabraProviderConfiguration extends Omit<HocuspocusProviderConfig
   /** WebSocket URL. Derived from client.wsUrl if client is provided. */
   url?: string;
   /** Shared WebSocket connection (use when multiplexing multiple root documents). */
-  websocketProvider?: HocuspocusProviderWebsocket;
+  websocketProvider?: AbracadabraWS;
 }
 /**
- * AbracadabraProvider extends HocuspocusProvider with:
+ * AbracadabraProvider extends AbracadabraBaseProvider with:
  *
  *  1. Subdocument lifecycle – intercepts Y.Doc subdoc events and syncs them
  *     with the server via MSG_SUBDOC (4) frames.  Child documents get their
@@ -314,7 +376,7 @@ interface AbracadabraProviderConfiguration extends Omit<HocuspocusProviderConfig
  *     can gate write operations without a network round-trip.  Role is
  *     refreshed from the server on every reconnect.
  */
-declare class AbracadabraProvider extends HocuspocusProvider {
+declare class AbracadabraProvider extends AbracadabraBaseProvider {
   effectiveRole: EffectiveRole;
   private _client;
   private offlineStore;
@@ -426,6 +488,37 @@ declare class Encoder {
   bufs: Array<Uint8Array>;
 }
 //#endregion
+//#region packages/provider/src/CloseEvents.d.ts
+interface CloseEvent {
+  code: number;
+  reason: string;
+}
+/**
+ * The server is terminating the connection because a data frame was received
+ * that is too large.
+ * See: https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code
+ */
+declare const MessageTooBig: CloseEvent;
+/**
+ * The server successfully processed the request, asks that the requester reset
+ * its document view, and is not returning any content.
+ */
+declare const ResetConnection: CloseEvent;
+/**
+ * Similar to Forbidden, but specifically for use when authentication is required and has
+ * failed or has not yet been provided.
+ */
+declare const Unauthorized: CloseEvent;
+/**
+ * The request contained valid data and was understood by the server, but the server
+ * is refusing action.
+ */
+declare const Forbidden: CloseEvent;
+/**
+ * The server timed out waiting for the request.
+ */
+declare const ConnectionTimeout: CloseEvent;
+//#endregion
 //#region node_modules/lib0/decoding.d.ts
 /**
  * A Decoder handles the decoding of an Uint8Array.
@@ -518,6 +611,16 @@ declare class UpdateMessage extends OutgoingMessage {
 }
 //#endregion
 //#region packages/provider/src/types.d.ts
+/**
+ * State of the WebSocket connection.
+ * https://developer.mozilla.org/de/docs/Web/API/WebSocket/readyState
+ */
+declare enum WsReadyStates {
+  Connecting = 0,
+  Open = 1,
+  Closing = 2,
+  Closed = 3
+}
 declare enum MessageType {
   Sync = 0,
   Awareness = 1,
@@ -661,14 +764,55 @@ interface HealthStatus {
   version: string;
   active_documents: number;
 }
+interface ServerInfo {
+  /** Human-readable server name set by the operator. */
+  name?: string;
+  /** Server version string. */
+  version?: string;
+  /** Entry-point document ID advertised by the server, if configured. */
+  index_doc_id?: string;
+}
+interface SearchResult {
+  docId: string;
+  /** Number of matching trigrams — higher is better. */
+  score: number;
+}
+interface InviteRow {
+  code: string;
+  createdBy: string | null;
+  role: string;
+  maxUses: number;
+  useCount: number;
+  expiresAt: number | null;
+  revoked: boolean;
+  createdAt: number;
+}
+type UploadQueueStatus = "pending" | "uploading" | "done" | "error";
+interface UploadQueueEntry {
+  /** Client-generated UUID. */
+  id: string;
+  docId: string;
+  /** File or Blob to upload. File extends Blob and survives IDB as Blob. */
+  file: Blob;
+  /** Eagerly captured filename (from File.name or explicit arg). */
+  filename: string;
+  status: UploadQueueStatus;
+  createdAt: number;
+  error?: string;
+}
 //#endregion
-//#region packages/provider/src/HocuspocusProviderWebsocket.d.ts
-type HocuspocusWebSocket = WebSocket & {
+//#region packages/provider/src/AbracadabraWS.d.ts
+type AbracadabraWebSocketConn = WebSocket & {
   identifier: string;
 };
-type HocusPocusWebSocket = HocuspocusWebSocket;
-type HocuspocusProviderWebsocketConfiguration = Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, "url">> & Partial<CompleteHocuspocusProviderWebsocketConfiguration>;
-interface CompleteHocuspocusProviderWebsocketConfiguration {
+/** @deprecated Use AbracadabraWebSocketConn */
+type HocuspocusWebSocket = AbracadabraWebSocketConn;
+/** @deprecated Use AbracadabraWebSocketConn */
+type HocusPocusWebSocket = AbracadabraWebSocketConn;
+type AbracadabraWSConfiguration = Required<Pick<CompleteAbracadabraWSConfiguration, "url">> & Partial<CompleteAbracadabraWSConfiguration>;
+/** @deprecated Use AbracadabraWSConfiguration */
+type HocuspocusProviderWebsocketConfiguration = AbracadabraWSConfiguration;
+interface CompleteAbracadabraWSConfiguration {
   /**
    * Whether to connect automatically when creating the provider instance. Default=true
    */
@@ -736,12 +880,14 @@ interface CompleteHocuspocusProviderWebsocketConfiguration {
   /**
    * Map of attached providers keyed by documentName.
    */
-  providerMap: Map<string, HocuspocusProvider>;
+  providerMap: Map<string, AbracadabraBaseProvider>;
 }
-declare class HocuspocusProviderWebsocket extends EventEmitter {
+/** @deprecated Use CompleteAbracadabraWSConfiguration */
+type CompleteHocuspocusProviderWebsocketConfiguration = CompleteAbracadabraWSConfiguration;
+declare class AbracadabraWS extends EventEmitter {
   private messageQueue;
-  configuration: CompleteHocuspocusProviderWebsocketConfiguration;
-  webSocket: HocusPocusWebSocket | null;
+  configuration: CompleteAbracadabraWSConfiguration;
+  webSocket: AbracadabraWebSocketConn | null;
   webSocketHandlers: {
     [key: string]: any;
   };
@@ -754,15 +900,15 @@ declare class HocuspocusProviderWebsocket extends EventEmitter {
     resolve: (value?: any) => void;
     reject: (reason?: any) => void;
   } | null;
-  constructor(configuration: HocuspocusProviderWebsocketConfiguration);
+  constructor(configuration: AbracadabraWSConfiguration);
   receivedOnOpenPayload?: Event | undefined;
   onOpen(event: Event): Promise<void>;
-  attach(provider: HocuspocusProvider): void;
-  detach(provider: HocuspocusProvider): void;
-  setConfiguration(configuration?: Partial<HocuspocusProviderWebsocketConfiguration>): void;
+  attach(provider: AbracadabraBaseProvider): void;
+  detach(provider: AbracadabraBaseProvider): void;
+  setConfiguration(configuration?: Partial<AbracadabraWSConfiguration>): void;
   cancelWebsocketRetry?: () => void;
   connect(): Promise<unknown>;
-  attachWebSocketListeners(ws: HocusPocusWebSocket, reject: Function): void;
+  attachWebSocketListeners(ws: AbracadabraWebSocketConn, reject: Function): void;
   cleanupWebSocket(): void;
   createWebSocketConnection(): Promise<unknown>;
   onMessage(event: MessageEvent): void;
@@ -780,10 +926,16 @@ declare class HocuspocusProviderWebsocket extends EventEmitter {
   }: onCloseParameters): void;
   destroy(): void;
 }
+/** @deprecated Use AbracadabraWS */
+declare const HocuspocusProviderWebsocket: typeof AbracadabraWS;
+/** @deprecated Use AbracadabraWS */
+type HocuspocusProviderWebsocket = AbracadabraWS;
 //#endregion
-//#region packages/provider/src/HocuspocusProvider.d.ts
-type HocuspocusProviderConfiguration = Required<Pick<CompleteHocuspocusProviderConfiguration, "name">> & Partial<CompleteHocuspocusProviderConfiguration> & ((Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, "url">> & Partial<Pick<CompleteHocuspocusProviderWebsocketConfiguration, "preserveTrailingSlash">>) | Required<Pick<CompleteHocuspocusProviderConfiguration, "websocketProvider">>);
-interface CompleteHocuspocusProviderConfiguration {
+//#region packages/provider/src/AbracadabraBaseProvider.d.ts
+type AbracadabraBaseProviderConfiguration = Required<Pick<CompleteAbracadabraBaseProviderConfiguration, "name">> & Partial<CompleteAbracadabraBaseProviderConfiguration> & ((Required<Pick<CompleteAbracadabraWSConfiguration, "url">> & Partial<Pick<CompleteAbracadabraWSConfiguration, "preserveTrailingSlash">>) | Required<Pick<CompleteAbracadabraBaseProviderConfiguration, "websocketProvider">>);
+/** @deprecated Use AbracadabraBaseProviderConfiguration */
+type HocuspocusProviderConfiguration = AbracadabraBaseProviderConfiguration;
+interface CompleteAbracadabraBaseProviderConfiguration {
   /**
    * The identifier/name of your document
    */
@@ -798,17 +950,17 @@ interface CompleteHocuspocusProviderConfiguration {
    * You can disable sharing awareness information by passing `null`.
    * Note that having no awareness information shared across all connections will break our ping checks
    * and thus trigger reconnects. You should always have at least one Provider with enabled awareness per
-   * socket connection, or ensure that the Provider receives messages before running into `HocuspocusProviderWebsocket.messageReconnectTimeout`.
+   * socket connection, or ensure that the Provider receives messages before running into `AbracadabraWS.messageReconnectTimeout`.
    */
   awareness: Awareness | null;
   /**
-   * A token that’s sent to the backend for authentication purposes.
+   * A token that's sent to the backend for authentication purposes.
    */
   token: string | (() => string) | (() => Promise<string>) | null;
   /**
-   * Hocuspocus websocket provider
+   * Abracadabra websocket provider
    */
-  websocketProvider: HocuspocusProviderWebsocket;
+  websocketProvider: AbracadabraWS;
   /**
    * Force syncing the document in the defined interval.
    */
@@ -830,11 +982,13 @@ interface CompleteHocuspocusProviderConfiguration {
   onStateless: (data: onStatelessParameters) => void;
   onUnsyncedChanges: (data: onUnsyncedChangesParameters) => void;
 }
+/** @deprecated Use CompleteAbracadabraBaseProviderConfiguration */
+type CompleteHocuspocusProviderConfiguration = CompleteAbracadabraBaseProviderConfiguration;
 declare class AwarenessError extends Error {
   code: number;
 }
-declare class HocuspocusProvider extends EventEmitter {
-  configuration: CompleteHocuspocusProviderConfiguration;
+declare class AbracadabraBaseProvider extends EventEmitter {
+  configuration: CompleteAbracadabraBaseProviderConfiguration;
   isSynced: boolean;
   unsyncedChanges: number;
   isAuthenticated: boolean;
@@ -842,7 +996,7 @@ declare class HocuspocusProvider extends EventEmitter {
   manageSocket: boolean;
   private _isAttached;
   intervals: any;
-  constructor(configuration: HocuspocusProviderConfiguration);
+  constructor(configuration: AbracadabraBaseProviderConfiguration);
   boundDocumentUpdateHandler: (update: Uint8Array, origin: any) => void;
   boundAwarenessUpdateHandler: ({
     added,
@@ -858,7 +1012,7 @@ declare class HocuspocusProvider extends EventEmitter {
   forwardDisconnect: (e: onDisconnectParameters) => this;
   forwardDestroy: () => this;
   forwardRateLimited: () => this;
-  setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
+  setConfiguration(configuration?: Partial<AbracadabraBaseProviderConfiguration>): void;
   get document(): Y.Doc;
   get isAttached(): boolean;
   get awareness(): Awareness | null;
@@ -901,6 +1055,10 @@ declare class HocuspocusProvider extends EventEmitter {
   authenticatedHandler(scope: string): void;
   setAwarenessField(key: string, value: any): void;
 }
+/** @deprecated Use AbracadabraBaseProvider */
+declare const HocuspocusProvider: typeof AbracadabraBaseProvider;
+/** @deprecated Use AbracadabraBaseProvider */
+type HocuspocusProvider = AbracadabraBaseProvider;
 //#endregion
 //#region packages/provider/src/OfflineStore.d.ts
 /**
@@ -957,6 +1115,23 @@ declare class OfflineStore {
   destroy(): void;
 }
 //#endregion
+//#region packages/provider/src/auth.d.ts
+declare enum AuthMessageType {
+  Token = 0,
+  PermissionDenied = 1,
+  Authenticated = 2
+}
+declare const writeAuthentication: (encoder: Encoder, auth: string) => void;
+declare const writePermissionDenied: (encoder: Encoder, reason: string) => void;
+declare const writeAuthenticated: (encoder: Encoder, scope: AuthorizedScope) => void;
+declare const writeTokenSyncRequest: (encoder: Encoder) => void;
+declare const readAuthMessage: (decoder: Decoder, sendToken: () => void, permissionDeniedHandler: (reason: string) => void, authenticatedHandler: (scope: string) => void) => void;
+//#endregion
+//#region packages/provider/src/awarenessStatesToArray.d.ts
+declare const awarenessStatesToArray: (states: Map<number, Record<string, any>>) => {
+  clientId: number;
+}[];
+//#endregion
 //#region packages/provider/src/OutgoingMessages/SubdocMessage.d.ts
 /**
  * Registers a new subdocument with the Abracadabra server.
@@ -1029,4 +1204,67 @@ declare class CryptoIdentityKeystore {
   clear(): Promise<void>;
 }
 //#endregion
-export { AbracadabraClient, AbracadabraClientConfig, AbracadabraOutgoingMessageArguments, AbracadabraProvider, AbracadabraProviderConfiguration, AuthorizedScope, AwarenessError, CompleteHocuspocusProviderConfiguration, CompleteHocuspocusProviderWebsocketConfiguration, Constructable, ConstructableOutgoingMessage, CryptoIdentity, CryptoIdentityKeystore, DocumentMeta, EffectiveRole, HealthStatus, HocusPocusWebSocket, HocuspocusProvider, HocuspocusProviderConfiguration, HocuspocusProviderWebsocket, HocuspocusProviderWebsocketConfiguration, HocuspocusWebSocket, MessageType, OfflineStore, OutgoingMessageArguments, OutgoingMessageInterface, PendingSubdoc, PermissionEntry, PublicKeyInfo, StatesArray, SubdocMessage, SubdocRegisteredEvent, UploadInfo, UploadMeta, UserProfile, WebSocketStatus, onAuthenticatedParameters, onAuthenticationFailedParameters, onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatelessParameters, onStatusParameters, onSubdocLoadedParameters, onSubdocRegisteredParameters, onSyncedParameters, onUnsyncedChangesParameters };
+//#region packages/provider/src/SearchIndex.d.ts
+declare class SearchIndex {
+  private readonly origin;
+  private dbPromise;
+  private db;
+  constructor(serverOrigin: string);
+  private getDb;
+  /**
+   * Replace the index for docId with the given texts.
+   * Old trigram associations are removed before new ones are added.
+   */
+  index(docId: string, texts: string[]): Promise<void>;
+  /** Remove all indexed content for a document. */
+  remove(docId: string): Promise<void>;
+  /**
+   * Search for documents matching the query.
+   * Returns results sorted by score (matching trigram count) descending.
+   */
+  search(query: string, limit?: number): Promise<SearchResult[]>;
+  destroy(): void;
+}
+//#endregion
+//#region packages/provider/src/FileBlobStore.d.ts
+declare class FileBlobStore extends EventEmitter {
+  private readonly origin;
+  private readonly client;
+  private dbPromise;
+  private db;
+  /** Tracks active object URLs so we can revoke them on destroy. */
+  private readonly objectUrls;
+  /** Prevents concurrent flush runs. */
+  private _flushing;
+  private readonly _onlineHandler;
+  constructor(serverOrigin: string, client: AbracadabraClient);
+  private getDb;
+  private blobKey;
+  /**
+   * Return a local object URL for a file.
+   * On first call the blob is downloaded from the server and cached in IDB.
+   * Returns null when offline and the blob is not yet cached, or when
+   * URL.createObjectURL is unavailable (e.g. Node.js / SSR).
+   */
+  getBlobUrl(docId: string, uploadId: string): Promise<string | null>;
+  /** Revoke the object URL and remove the blob from cache. */
+  evictBlob(docId: string, uploadId: string): Promise<void>;
+  /**
+   * Queue a file for upload. Works offline — the entry is persisted to IDB
+   * and flushed the next time the queue is flushed.
+   * Returns the generated queue entry id.
+   */
+  queueUpload(docId: string, file: File | Blob, filename?: string): Promise<string>;
+  /** Return all upload queue entries. */
+  getQueue(): Promise<UploadQueueEntry[]>;
+  /**
+   * Upload all pending queue entries via AbracadabraClient.
+   * Safe to call repeatedly — a concurrent call is a no-op.
+   * Entries that fail are marked with status "error" and left in the queue.
+   */
+  flushQueue(): Promise<void>;
+  private _updateQueueEntry;
+  destroy(): void;
+}
+//#endregion
+export { AbracadabraBaseProvider, AbracadabraBaseProviderConfiguration, AbracadabraClient, AbracadabraClientConfig, AbracadabraOutgoingMessageArguments, AbracadabraProvider, AbracadabraProviderConfiguration, AbracadabraWS, AbracadabraWSConfiguration, AbracadabraWebSocketConn, AuthMessageType, AuthorizedScope, AwarenessError, CloseEvent, CompleteAbracadabraBaseProviderConfiguration, CompleteAbracadabraWSConfiguration, CompleteHocuspocusProviderConfiguration, CompleteHocuspocusProviderWebsocketConfiguration, ConnectionTimeout, Constructable, ConstructableOutgoingMessage, CryptoIdentity, CryptoIdentityKeystore, DocumentCache, type DocumentCacheOptions, DocumentMeta, EffectiveRole, FileBlobStore, Forbidden, HealthStatus, HocusPocusWebSocket, HocuspocusProvider, HocuspocusProviderConfiguration, HocuspocusProviderWebsocket, HocuspocusProviderWebsocketConfiguration, HocuspocusWebSocket, InviteRow, MessageTooBig, MessageType, OfflineStore, OutgoingMessageArguments, OutgoingMessageInterface, PendingSubdoc, PermissionEntry, PublicKeyInfo, ResetConnection, SearchIndex, SearchResult, ServerInfo, StatesArray, SubdocMessage, SubdocRegisteredEvent, Unauthorized, UploadInfo, UploadMeta, UploadQueueEntry, UploadQueueStatus, UserProfile, WebSocketStatus, WsReadyStates, awarenessStatesToArray, onAuthenticatedParameters, onAuthenticationFailedParameters, onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatelessParameters, onStatusParameters, onSubdocLoadedParameters, onSubdocRegisteredParameters, onSyncedParameters, onUnsyncedChangesParameters, readAuthMessage, writeAuthenticated, writeAuthentication, writePermissionDenied, writeTokenSyncRequest };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abraca/dabra",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "abracadabra provider",
   "keywords": [
     "abracadabra",
@@ -28,7 +28,6 @@
     "dist"
   ],
   "dependencies": {
-    "@abraca/dabra-common": "^0.1.1",
     "@lifeomic/attempt": "^3.1.0",
     "@noble/ed25519": "^2.3.0",
     "@noble/hashes": "^1.8.0",

package/src/{HocuspocusProvider.ts → AbracadabraBaseProvider.ts}

@@ -1,10 +1,10 @@
-import { awarenessStatesToArray } from "@abraca/dabra-common";
+import { awarenessStatesToArray } from "./awarenessStatesToArray.ts";
 import type { Event, MessageEvent } from "ws";
 import { Awareness, removeAwarenessStates } from "y-protocols/awareness";
 import * as Y from "yjs";
 import EventEmitter from "./EventEmitter.ts";
-import type { CompleteHocuspocusProviderWebsocketConfiguration } from "./HocuspocusProviderWebsocket.ts";
-import { HocuspocusProviderWebsocket } from "./HocuspocusProviderWebsocket.ts";
+import type { CompleteAbracadabraWSConfiguration } from "./AbracadabraWS.ts";
+import { AbracadabraWS } from "./AbracadabraWS.ts";
 import { IncomingMessage } from "./IncomingMessage.ts";
 import { MessageReceiver } from "./MessageReceiver.ts";
 import { MessageSender } from "./MessageSender.ts";
@@ -31,17 +31,20 @@ import type {
   onUnsyncedChangesParameters,
 } from "./types.ts";
 
-export type HocuspocusProviderConfiguration = Required<
-  Pick<CompleteHocuspocusProviderConfiguration, "name">
+export type AbracadabraBaseProviderConfiguration = Required<
+  Pick<CompleteAbracadabraBaseProviderConfiguration, "name">
 > &
-  Partial<CompleteHocuspocusProviderConfiguration> &
+  Partial<CompleteAbracadabraBaseProviderConfiguration> &
   (
-    | (Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, "url">> &
-        Partial<Pick<CompleteHocuspocusProviderWebsocketConfiguration, "preserveTrailingSlash">>)
-    | Required<Pick<CompleteHocuspocusProviderConfiguration, "websocketProvider">>
+    | (Required<Pick<CompleteAbracadabraWSConfiguration, "url">> &
+        Partial<Pick<CompleteAbracadabraWSConfiguration, "preserveTrailingSlash">>)
+    | Required<Pick<CompleteAbracadabraBaseProviderConfiguration, "websocketProvider">>
   );
 
-export interface CompleteHocuspocusProviderConfiguration {
+/** @deprecated Use AbracadabraBaseProviderConfiguration */
+export type HocuspocusProviderConfiguration = AbracadabraBaseProviderConfiguration;
+
+export interface CompleteAbracadabraBaseProviderConfiguration {
   /**
    * The identifier/name of your document
    */
@@ -57,19 +60,19 @@ export interface CompleteHocuspocusProviderConfiguration {
    * You can disable sharing awareness information by passing `null`.
    * Note that having no awareness information shared across all connections will break our ping checks
    * and thus trigger reconnects. You should always have at least one Provider with enabled awareness per
-   * socket connection, or ensure that the Provider receives messages before running into `HocuspocusProviderWebsocket.messageReconnectTimeout`.
+   * socket connection, or ensure that the Provider receives messages before running into `AbracadabraWS.messageReconnectTimeout`.
    */
   awareness: Awareness | null;
 
   /**
-   * A token that’s sent to the backend for authentication purposes.
+   * A token that's sent to the backend for authentication purposes.
    */
   token: string | (() => string) | (() => Promise<string>) | null;
 
   /**
-   * Hocuspocus websocket provider
+   * Abracadabra websocket provider
    */
-  websocketProvider: HocuspocusProviderWebsocket;
+  websocketProvider: AbracadabraWS;
 
   /**
    * Force syncing the document in the defined interval.
@@ -94,12 +97,15 @@ export interface CompleteHocuspocusProviderConfiguration {
   onUnsyncedChanges: (data: onUnsyncedChangesParameters) => void;
 }
 
+/** @deprecated Use CompleteAbracadabraBaseProviderConfiguration */
+export type CompleteHocuspocusProviderConfiguration = CompleteAbracadabraBaseProviderConfiguration;
+
 export class AwarenessError extends Error {
   code = 1001;
 }
 
-export class HocuspocusProvider extends EventEmitter {
-  public configuration: CompleteHocuspocusProviderConfiguration = {
+export class AbracadabraBaseProvider extends EventEmitter {
+  public configuration: CompleteAbracadabraBaseProviderConfiguration = {
     name: "",
     // @ts-ignore
     document: undefined,
@@ -142,7 +148,7 @@ export class HocuspocusProvider extends EventEmitter {
     forceSync: null,
   };
 
-  constructor(configuration: HocuspocusProviderConfiguration) {
+  constructor(configuration: AbracadabraBaseProviderConfiguration) {
     super();
     this.setConfiguration(configuration);
 
@@ -220,11 +226,11 @@ export class HocuspocusProvider extends EventEmitter {
 
   forwardRateLimited = () => this.emit("rateLimited");
 
-  public setConfiguration(configuration: Partial<HocuspocusProviderConfiguration> = {}): void {
+  public setConfiguration(configuration: Partial<AbracadabraBaseProviderConfiguration> = {}): void {
     if (!configuration.websocketProvider) {
       this.manageSocket = true;
-      this.configuration.websocketProvider = new HocuspocusProviderWebsocket(
-        configuration as CompleteHocuspocusProviderWebsocketConfiguration,
+      this.configuration.websocketProvider = new AbracadabraWS(
+        configuration as CompleteAbracadabraWSConfiguration,
       );
     }
 
@@ -366,7 +372,7 @@ export class HocuspocusProvider extends EventEmitter {
     }
 
     console.warn(
-      "HocuspocusProvider::connect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.",
+      "AbracadabraBaseProvider::connect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.",
     );
   }
 
@@ -376,7 +382,7 @@ export class HocuspocusProvider extends EventEmitter {
     }
 
     console.warn(
-      "HocuspocusProvider::disconnect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.",
+      "AbracadabraBaseProvider::disconnect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.",
     );
   }
 
@@ -553,3 +559,8 @@ export class HocuspocusProvider extends EventEmitter {
     this.awareness.setLocalStateField(key, value);
   }
 }
+
+/** @deprecated Use AbracadabraBaseProvider */
+export const HocuspocusProvider = AbracadabraBaseProvider;
+/** @deprecated Use AbracadabraBaseProvider */
+export type HocuspocusProvider = AbracadabraBaseProvider;