@atlaskit/collab-provider 8.4.0 → 8.6.0

package/dist/esm/types.js

@@ -1,7 +1,14 @@
+// Initial draft
+
+/**
+ * @deprecated Use ProviderError type instead
+ */
+
 // Channel
 
 export var AcknowledgementResponseTypes;
 (function (AcknowledgementResponseTypes) {
   AcknowledgementResponseTypes["SUCCESS"] = "SUCCESS";
   AcknowledgementResponseTypes["ERROR"] = "ERROR";
-})(AcknowledgementResponseTypes || (AcknowledgementResponseTypes = {}));
+})(AcknowledgementResponseTypes || (AcknowledgementResponseTypes = {})); // ESS-2916 Type def for namespace status - lock/unlock
+// Catchup

package/dist/esm/version-wrapper.js

@@ -1,5 +1,5 @@
 export var name = "@atlaskit/collab-provider";
-export var version = "8.4.0";
+export var version = "8.6.0";
 export var nextMajorVersion = function nextMajorVersion() {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/collab-provider",
-	"version": "8.4.0",
+	"version": "8.6.0",
 	"sideEffects": false
 }

package/dist/types/analytics/{index.d.ts → analytics-helper.d.ts}

@@ -2,8 +2,10 @@ 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);
+    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/analytics/performance.d.ts

@@ -1,4 +1,4 @@
-import AnalyticsHelper from '.';
+import AnalyticsHelper from './analytics-helper';
 export declare enum MEASURE_NAME {
     SOCKET_CONNECT = "socketConnect",
     DOCUMENT_INIT = "documentInit",
@@ -6,6 +6,8 @@ export declare enum MEASURE_NAME {
     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;

package/dist/types/analytics/ufo.d.ts

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

package/dist/types/channel.d.ts

@@ -1,7 +1,7 @@
 import { Emitter } from './emitter';
 import type { Config, ChannelEvent, CatchupResponse, Metadata } from './types';
 import type { Socket } from 'socket.io-client';
-import AnalyticsHelper from './analytics';
+import AnalyticsHelper from './analytics/analytics-helper';
 export declare class Channel extends Emitter<ChannelEvent> {
     private connected;
     private config;
@@ -22,18 +22,25 @@ export declare class Channel extends Emitter<ChannelEvent> {
     /**
      * Connect to collab service using websockets
      */
-    connect(): void;
+    connect(shouldInitialize?: boolean): void;
     private handlePermissionInvalidateToken;
     private onConnectError;
     private onReconnectError;
     private onConnect;
     private onReceiveData;
-    fetchCatchup(fromVersion: number): Promise<CatchupResponse>;
+    fetchCatchup: (fromVersion: number) => Promise<CatchupResponse>;
     /**
-     * Send message to service. Timestamp will be added server side.
+     * 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;
-    sendMetadata(metadata: Metadata): void;
+    broadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], "timestamp">, callback?: Function | undefined) => void;
+    /**
+     * Send metadata to 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/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/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/errors/error-code-mapper.d.ts

@@ -1,36 +1,2 @@
-import type { CollabErrorPayload, ErrorPayload } from '../types';
-export declare const ErrorCodeMapper: {
-    noPermissionError: {
-        code: string;
-        message: string;
-    };
-    documentNotFound: {
-        code: string;
-        message: string;
-    };
-    hasToLogin: {
-        code: string;
-        message: string;
-    };
-    catchupFail: {
-        code: string;
-        message: string;
-    };
-    serviceUnvailable: {
-        code: string;
-        message: string;
-    };
-    failToSave: {
-        code: string;
-        message: string;
-    };
-    restoreError: {
-        code: string;
-        message: string;
-    };
-    internalError: {
-        code: string;
-        message: string;
-    };
-};
-export declare const errorCodeMapper: (error: ErrorPayload) => CollabErrorPayload | undefined;
+import { InternalError, ProviderError } from './error-types';
+export declare const errorCodeMapper: (error: InternalError) => ProviderError | undefined;