@atlaskit/collab-provider 8.8.2 → 8.9.1

package/dist/types/provider/index.d.ts

@@ -13,7 +13,7 @@ export declare class Provider extends Emitter<CollabEvents> implements BaseEvent
     private isChannelInitialized;
     private initialDraft?;
     private isProviderInitialized;
-    private isNamespaceLocked;
+    private isPreinitializing;
     private sessionId?;
     private clientId?;
     private userId?;
@@ -22,7 +22,16 @@ export declare class Provider extends Emitter<CollabEvents> implements BaseEvent
     private readonly participantsService;
     private readonly metadataService;
     private readonly documentService;
+    private readonly namespaceService;
+    /**
+     * Wrapper for this.emit, it binds scope for callbacks and waits for initialising of the editor before emitting events.
+     * Waiting for the collab provider to become connected to the editor ensures the editor doesn't miss any events.
+     * @param evt - Event name to emit to subscribers
+     * @param data - Event data to emit to subscribers
+     */
     private readonly emitCallback;
+    private getStatePromise;
+    getStatePromiseResolve: (value: void | PromiseLike<void>) => void;
     constructor(config: Config);
     private initializeChannel;
     /**
@@ -33,14 +42,19 @@ export declare class Provider extends Emitter<CollabEvents> implements BaseEvent
      */
     initialize(getState: () => EditorState): this;
     /**
-     * Initialisation logic, called by the editor in the collab-edit plugin
-     * @param {Object} parameters ...
-     * @param {Function} parameters.getState Function that returns the editor state, used to retrieve collab-edit properties and to interact with prosemirror-collab
-     * @param {SyncUpErrorFunction} parameters.onSyncUpError (Optional) Function that gets called when the sync of steps fails after retrying 30 times, used by Editor to log to analytics
+     * Initialisation logic, called by the editor in the collab-edit plugin.
+     *
+     * When getState is nullish and a initialDraft is provided the collab provider is in a state of pre-initialization,
+     * the provider starts to enable the connection to NCS, but the provider will not emit any events until this function
+     * is called again with a getState function, indicating that the editor is loaded and ready to receive the emits.
+     *
+     * @param {Object} options ...
+     * @param {Function} options.getState Function that returns the editor state, used to retrieve collab-edit properties and to interact with prosemirror-collab
+     * @param {SyncUpErrorFunction} options.onSyncUpError (Optional) Function that gets called when the sync of steps fails after retrying 30 times, used by Editor to log to analytics
      * @throws {ProviderInitialisationError} Something went wrong during provider initialisation
      */
     setup({ getState, onSyncUpError, }: {
-        getState: () => EditorState;
+        getState?: () => EditorState;
         onSyncUpError?: SyncUpErrorFunction;
     }): this;
     private checkForCookies;
@@ -65,32 +79,6 @@ export declare class Provider extends Emitter<CollabEvents> implements BaseEvent
      * @param {string} data.sessionId Identifier identifying the session
      */
     sendMessage(data: CollabEventTelepointerData): void;
-    private sendPresence;
-    /**
-     * Called when a participant joins the session.
-     *
-     * We keep track of participants internally in this class, and emit the `presence` event to update
-     * the active avatars in the editor.
-     * This method will be triggered from backend to notify all participants to exchange presence
-     */
-    private onPresenceJoined;
-    private onPresence;
-    /**
-     * Called when a participant leaves the session.
-     *
-     * We emit the `presence` event to update the active avatars in the editor.
-     */
-    private onParticipantLeft;
-    private startInactiveRemover;
-    /**
-     * Called when we receive an update event from another participant.
-     */
-    private onParticipantUpdated;
-    /**
-     * Called when we receive a telepointer update from another
-     * participant.
-     */
-    private onParticipantTelepointer;
     private onDisconnected;
     /**
      * "Destroy" the provider, disconnect it's connection to the back-end service and unsubscribe all event listeners on the provider.
@@ -150,10 +138,6 @@ export declare class Provider extends Emitter<CollabEvents> implements BaseEvent
      */
     getFinalAcknowledgedState: () => Promise<ResolvedEditorState>;
     getUnconfirmedSteps: () => readonly ProseMirrorStep[] | undefined;
-    /**
-     * ESS-2916 namespace status event- lock/unlock
-     */
-    private onNamespaceStatusChanged;
     /**
      * Used when the provider is disconnected or destroyed to prevent perpetual timers from continuously running
      */

package/dist/types/types.d.ts

@@ -250,7 +250,7 @@ export interface CollabSendableSelection {
 export interface CollabEditProvider<Events extends CollabEvents = CollabEvents> {
     initialize(getState: () => any, createStep: (json: object) => Step): this;
     setup(props: {
-        getState: () => EditorState;
+        getState?: () => EditorState;
         onSyncUpError?: SyncUpErrorFunction;
     }): this;
     send(tr: Transaction, oldState: EditorState, newState: EditorState): void;

package/dist/types-ts4.5/analytics/analytics-helper.d.ts

@@ -0,0 +1,11 @@
+import type { AnalyticsWebClient } from '@atlaskit/analytics-listeners';
+import type { ActionAnalyticsEvent, EVENT_STATUS } from '../helpers/const';
+export default class AnalyticsHelper {
+    analyticsClient: AnalyticsWebClient | undefined;
+    getAnalyticsClient: Promise<AnalyticsWebClient> | undefined;
+    documentAri: string;
+    constructor(documentAri: string, analyticsClient?: AnalyticsWebClient, getAnalyticsClient?: Promise<AnalyticsWebClient>);
+    sendErrorEvent(error: unknown, errorMessage: string): void;
+    sendActionEvent(action: ActionAnalyticsEvent['eventAction'], status: EVENT_STATUS, attributes?: Omit<ActionAnalyticsEvent['attributes'], 'documentAri' | 'eventStatus'>): void;
+    private sendEvent;
+}

package/dist/types-ts4.5/analytics/performance.d.ts

@@ -0,0 +1,15 @@
+import AnalyticsHelper from './analytics-helper';
+export declare enum MEASURE_NAME {
+    SOCKET_CONNECT = "socketConnect",
+    DOCUMENT_INIT = "documentInit",
+    COMMIT_UNCONFIRMED_STEPS = "commitUnconfirmedSteps",
+    PUBLISH_PAGE = "publishPage",
+    GET_CURRENT_STATE = "getCurrentState"
+}
+export declare const isPerformanceAPIAvailable: () => boolean;
+export declare const measureMap: Map<string, number>;
+export declare function startMeasure(measureName: MEASURE_NAME, analyticsHelper: AnalyticsHelper | undefined): void;
+export declare function stopMeasure(measureName: MEASURE_NAME, analyticsHelper: AnalyticsHelper | undefined, onMeasureComplete?: (duration: number, startTime: number) => void): {
+    duration: number;
+    startTime: number;
+} | undefined;

package/dist/types-ts4.5/analytics/ufo.d.ts

@@ -0,0 +1,3 @@
+import { UFOExperience } from '@atlaskit/ufo';
+import AnalyticsHelper from './analytics-helper';
+export declare const createDocInitExp: (analyticsHelper: AnalyticsHelper | undefined) => UFOExperience | undefined;

package/dist/types-ts4.5/channel.d.ts

@@ -0,0 +1,47 @@
+import { Emitter } from './emitter';
+import type { Config, ChannelEvent, CatchupResponse, Metadata } from './types';
+import type { Socket } from 'socket.io-client';
+import AnalyticsHelper from './analytics/analytics-helper';
+export declare class Channel extends Emitter<ChannelEvent> {
+    private connected;
+    private config;
+    private socket;
+    private reconnectHelper?;
+    private initialized;
+    private analyticsHelper?;
+    private initExperience?;
+    private token?;
+    private network;
+    constructor(config: Config, analyticsHelper: AnalyticsHelper);
+    getInitialized: () => boolean;
+    getConnected: () => boolean;
+    getSocket: () => Socket<import("@socket.io/component-emitter").DefaultEventsMap, import("@socket.io/component-emitter").DefaultEventsMap> | null;
+    getToken: () => string | undefined;
+    private setToken;
+    private unsetToken;
+    /**
+     * Connect to collab service using websockets
+     */
+    connect(shouldInitialize?: boolean): void;
+    private handlePermissionInvalidateToken;
+    private onConnectError;
+    private onReconnectError;
+    private onConnect;
+    private onReceiveData;
+    fetchCatchup: (fromVersion: number) => Promise<CatchupResponse>;
+    /**
+     * Send message to the back-end service over the channel. Timestamp will be added server side.
+     * @throws {NotInitializedError} Channel not initialized
+     * @throws {NotConnectedError} Channel not connected
+     */
+    broadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], "timestamp">, callback?: Function) => void;
+    /**
+     * Send metadata to the back-end service over the channel
+     * @throws {NotInitializedError} Channel not initialized
+     * @throws {NotConnectedError} Channel not connected
+     */
+    sendMetadata: (metadata: Metadata) => void;
+    sendPresenceJoined(): void;
+    onOnlineHandler: () => void;
+    disconnect(): void;
+}

package/dist/types-ts4.5/config.d.ts

@@ -0,0 +1,5 @@
+export declare const SOCKET_IO_OPTIONS: {
+    RECONNECTION_DELAY_MAX: number;
+    RECONNECTION_DELAY: number;
+    RANDOMIZATION_FACTOR: number;
+};

package/dist/types-ts4.5/connectivity/network.d.ts

@@ -0,0 +1,17 @@
+export declare enum NetworkStatus {
+    ONLINE = "ONLINE",
+    OFFLINE = "OFFLINE"
+}
+export interface NetworkProps {
+    initialStatus?: NetworkStatus;
+    onlineCallback?: () => void;
+}
+export default class Network {
+    status?: NetworkStatus;
+    onlineCallback?: () => void;
+    constructor(props?: NetworkProps);
+    private offlineHandler;
+    private onlineHandler;
+    getStatus(): NetworkStatus | null;
+    destroy(): void;
+}

package/dist/types-ts4.5/connectivity/reconnect-helper.d.ts

@@ -0,0 +1,8 @@
+export default class ReconnectHelper {
+    failedReconnectCount: number;
+    constructor();
+    private onlineHandler;
+    countReconnectError(): void;
+    isLikelyNetworkIssue(): boolean;
+    destroy(): void;
+}

package/dist/types-ts4.5/connectivity/singleton.d.ts

@@ -0,0 +1,3 @@
+import Network from './network';
+declare const network: Network;
+export { network };

package/dist/types-ts4.5/disconnected-reason-mapper.d.ts

@@ -0,0 +1,16 @@
+export declare const socketIOReasons: {
+    IO_CLIENT_DISCONNECT: string;
+    IO_SERVER_DISCONNECT: string;
+    TRANSPORT_CLOSED: string;
+    TRANSPORT_ERROR: string;
+    PING_TIMEOUT: string;
+};
+export declare enum DisconnectReason {
+    CLIENT_DISCONNECT = "CLIENT_DISCONNECT",
+    SERVER_DISCONNECT = "SERVER_DISCONNECT",
+    SOCKET_CLOSED = "SOCKET_CLOSED",
+    SOCKET_ERROR = "SOCKET_ERROR",
+    SOCKET_TIMEOUT = "SOCKET_TIMEOUT",
+    UNKNOWN_DISCONNECT = "UNKNOWN_DISCONNECT"
+}
+export declare const disconnectedReasonMapper: (reason: string) => DisconnectReason;

package/dist/types-ts4.5/document/catchup.d.ts

@@ -0,0 +1,9 @@
+import type { CatchupOptions } from '../types';
+import { Mapping, Step } from 'prosemirror-transform';
+/**
+ * Rebase the steps based on the mapping pipeline.
+ * Some steps could be lost, if they are no longer
+ * invalid after rebased.
+ */
+export declare function rebaseSteps(steps: readonly Step[], mapping: Mapping): Step[];
+export declare const catchup: (opt: CatchupOptions) => Promise<void>;

package/dist/types-ts4.5/document/document-service.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="lodash" />
+import AnalyticsHelper from '../analytics/analytics-helper';
+import { CatchupResponse, ChannelEvent, CollabEvents, CollabInitPayload, StepsPayload } from '../types';
+import type { Step as ProseMirrorStep } from 'prosemirror-transform';
+import type { MetadataService } from '../metadata/metadata-service';
+import { SyncUpErrorFunction } from '@atlaskit/editor-common/types';
+import type { EditorState, Transaction } from 'prosemirror-state';
+import { ResolvedEditorState } from '@atlaskit/editor-common/collab';
+import { ParticipantsService } from '../participants/participants-service';
+import type { InternalError } from '../errors/error-types';
+export declare class DocumentService {
+    private participantsService;
+    private analyticsHelper;
+    private fetchCatchup;
+    private providerEmitCallback;
+    private broadcast;
+    private getUserId;
+    private onErrorHandled;
+    private metadataService;
+    private getState;
+    private onSyncUpError?;
+    private stepQueue;
+    private stepRejectCounter;
+    private clientId?;
+    /**
+     *
+     * @param participantsService - The participants service, used when users are detected active when making changes to the document
+     * and to emit their telepointers from steps they add
+     * @param analyticsHelper - Helper for analytics events
+     * @param fetchCatchup - Function to fetch "catchup" data, data required to rebase current steps to the latest version.
+     * @param providerEmitCallback - Callback for emitting events to listeners on the provider
+     * @param broadcastMetadata - Callback for broadcasting metadata changes to other clients
+     * @param broadcast - Callback for broadcasting events to other clients
+     * @param getUserId - Callback to fetch the current user's ID
+     * @param onErrorHandled - Callback to handle
+     */
+    constructor(participantsService: ParticipantsService, analyticsHelper: AnalyticsHelper | undefined, fetchCatchup: (fromVersion: number) => Promise<CatchupResponse>, providerEmitCallback: (evt: keyof CollabEvents, data: any) => void, broadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], 'timestamp'>, callback?: Function) => void, getUserId: () => string | undefined, onErrorHandled: (error: InternalError) => void, metadataService: MetadataService);
+    /**
+     * To prevent calling catchup to often, use lodash throttle to reduce the frequency
+     */
+    throttledCatchup: import("lodash").DebouncedFunc<() => Promise<void>>;
+    /**
+     * Called when:
+     *   * session established(offline -> online)
+     *   * try to accept steps but version is behind.
+     */
+    private catchup;
+    getCurrentPmVersion: () => number;
+    private processQueue;
+    getCurrentState: () => Promise<ResolvedEditorState>;
+    private processSteps;
+    getUnconfirmedStepsOrigins: () => readonly Transaction<any>[] | undefined;
+    getUnconfirmedSteps: () => readonly ProseMirrorStep[] | undefined;
+    private applyLocalSteps;
+    /**
+     * Called when we receive steps from the service
+     */
+    onStepsAdded: (data: StepsPayload) => void;
+    onRestore: ({ doc, version, metadata }: CollabInitPayload) => void;
+    getFinalAcknowledgedState: () => Promise<ResolvedEditorState>;
+    updateDocument: ({ doc, version, metadata, reserveCursor, }: CollabInitPayload) => void;
+    /**
+     * Commit the unconfirmed local steps to the back-end service
+     * @throws {Error} Couldn't sync the steps after retrying 30 times
+     */
+    commitUnconfirmedSteps: () => Promise<void>;
+    setup({ getState, onSyncUpError, clientId, }: {
+        getState: () => EditorState;
+        onSyncUpError?: SyncUpErrorFunction;
+        clientId: number | string | undefined;
+    }): this;
+    /**
+     * We can use this function to throttle/delay
+     * Any send steps operation
+     *
+     * The getState function will return the current EditorState
+     * from the EditorView.
+     */
+    sendStepsFromCurrentState(): void;
+    onStepRejectedError: () => void;
+    /**
+     * Send steps from transaction to other participants
+     * It needs the superfluous arguments because we keep the interface of the send API the same as the Synchrony plugin
+     */
+    send(_tr: Transaction | null, _oldState: EditorState | null, newState: EditorState): void;
+}

package/dist/types-ts4.5/document/step-queue-state.d.ts

@@ -0,0 +1,16 @@
+import { StepsPayload } from '../types';
+export declare class StepQueueState {
+    private queuePaused;
+    private queue;
+    queueSteps(data: StepsPayload): void;
+    getQueue: () => StepsPayload[];
+    filterQueue: (condition: (stepsPayload: StepsPayload) => boolean) => void;
+    /**
+     * Get whether the document service has stopped processing new steps whilst it carries out processes such as catchup.
+     * Exposed for testing
+     */
+    isPaused: () => boolean;
+    pauseQueue: () => void;
+    resumeQueue: () => void;
+    shift: () => StepsPayload | undefined;
+}

package/dist/types-ts4.5/emitter.d.ts

@@ -0,0 +1,19 @@
+export declare class Emitter<T = any> {
+    private eventEmitter;
+    /**
+     * Emit events to subscribers
+     */
+    protected emit<K extends keyof T>(evt: K, data: T[K]): this;
+    /**
+     * Subscribe to events emitted by this provider
+     */
+    on<K extends keyof T>(evt: K, handler: (args: T[K]) => void): this;
+    /**
+     * Unsubscribe from events emitted by this provider
+     */
+    off<K extends keyof T>(evt: K, handler: (args: T[K]) => void): this;
+    /**
+     * Unsubscribe from all events emitted by this provider.
+     */
+    unsubscribeAll<K extends keyof T>(evt?: K): this;
+}

package/dist/types-ts4.5/errors/error-code-mapper.d.ts

@@ -0,0 +1,2 @@
+import { InternalError, ProviderError } from './error-types';
+export declare const errorCodeMapper: (error: InternalError) => ProviderError | undefined;