@atlaskit/collab-provider 8.2.0 → 8.4.0

package/dist/esm/provider/telepointers.js

@@ -0,0 +1,69 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { createLogger } from '../helpers/utils';
+import { ExperiencePerformanceTypes, ExperienceTypes, UFOExperience } from '@atlaskit/ufo';
+import { AcknowledgementResponseTypes } from '../types';
+var logger = createLogger('Telepointer', 'green');
+export var telepointersFromStep = function telepointersFromStep(participants, step) {
+  var _Array$from$filter = Array.from(participants.values()).filter(function (p) {
+      return p.clientId === step.clientId;
+    }),
+    _Array$from$filter2 = _slicedToArray(_Array$from$filter, 1),
+    participant = _Array$from$filter2[0];
+  if (participant) {
+    var _node$text;
+    var stepType = step.stepType,
+      to = step.to,
+      from = step.from,
+      _step$slice = step.slice,
+      slice = _step$slice === void 0 ? {
+        content: []
+      } : _step$slice;
+    var _slice$content = _slicedToArray(slice.content, 1),
+      node = _slice$content[0];
+    if (to && from && stepType === 'replace' && to === from && slice.content.length === 1 && (node === null || node === void 0 ? void 0 : node.type) === 'text' && (node === null || node === void 0 ? void 0 : (_node$text = node.text) === null || _node$text === void 0 ? void 0 : _node$text.length) === 1) {
+      return {
+        sessionId: participant.sessionId,
+        selection: {
+          type: 'textSelection',
+          anchor: from + 1,
+          head: to + 1
+        },
+        type: 'telepointer'
+      };
+    }
+  }
+};
+export var telepointerCallback = function telepointerCallback(documentAri) {
+  var telepointerExperience = new UFOExperience('collab-provider.telepointer', {
+    type: ExperienceTypes.Operation,
+    performanceType: ExperiencePerformanceTypes.Custom,
+    performanceConfig: {
+      histogram: _defineProperty({}, ExperiencePerformanceTypes.Custom, {
+        duration: '250_500_1000_1500_2000_3000_4000'
+      })
+    }
+  });
+  telepointerExperience.addMetadata({
+    documentAri: documentAri
+  });
+  telepointerExperience.start();
+  return function (response) {
+    if (response.type === AcknowledgementResponseTypes.SUCCESS) {
+      telepointerExperience.success();
+    } else if (response.type === AcknowledgementResponseTypes.ERROR) {
+      var errorMessage = response.error;
+      telepointerExperience.addMetadata({
+        error: errorMessage
+      });
+      logger('Error from collab service with telepointer broadcast', errorMessage);
+      telepointerExperience.failure();
+    } else {
+      logger('Invalid ACK from collab service with telepointer broadcast');
+      telepointerExperience.addMetadata({
+        error: 'Invalid ACK from collab service with telepointer broadcast'
+      });
+      telepointerExperience.failure();
+    }
+  };
+};

package/dist/esm/version-wrapper.js

@@ -1,5 +1,5 @@
 export var name = "@atlaskit/collab-provider";
-export var version = "8.2.0";
+export var version = "8.4.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.2.0",
+	"version": "8.4.0",
 	"sideEffects": false
 }

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

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

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

@@ -1,12 +1,13 @@
+import AnalyticsHelper from '.';
 export declare enum MEASURE_NAME {
     SOCKET_CONNECT = "socketConnect",
     DOCUMENT_INIT = "documentInit",
-    CONVERT_PM_TO_ADF = "convertPMToADF",
-    COMMIT_UNCONFIRMED_STEPS = "commitUnconfirmedSteps"
+    COMMIT_UNCONFIRMED_STEPS = "commitUnconfirmedSteps",
+    PUBLISH_PAGE = "publishPage",
+    GET_CURRENT_STATE = "getCurrentState"
 }
-export declare function startMeasure(measureName: MEASURE_NAME): void;
-export declare function stopMeasure(measureName: MEASURE_NAME, onMeasureComplete?: (duration: number, startTime: number) => void): {
+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;
-export declare function clearMeasure(measureName: string): void;

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

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

package/dist/types/channel.d.ts

@@ -1,21 +1,31 @@
 import { Emitter } from './emitter';
-import type { Config, Socket, ChannelEvent, CatchupResponse, Metadata } from './types';
+import type { Config, ChannelEvent, CatchupResponse, Metadata } from './types';
+import type { Socket } from 'socket.io-client';
+import AnalyticsHelper from './analytics';
 export declare class Channel extends Emitter<ChannelEvent> {
     private connected;
     private config;
     private socket;
+    private reconnectHelper?;
     private initialized;
-    private analyticsClient?;
-    private initExperience;
-    constructor(config: Config);
+    private analyticsHelper?;
+    private initExperience?;
+    private token?;
+    private network;
+    constructor(config: Config, analyticsHelper: AnalyticsHelper);
     getInitialized: () => boolean;
     getConnected: () => boolean;
-    getSocket: () => Socket | null;
+    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(): void;
+    private handlePermissionInvalidateToken;
     private onConnectError;
+    private onReconnectError;
     private onConnect;
     private onReceiveData;
     fetchCatchup(fromVersion: number): Promise<CatchupResponse>;
@@ -25,5 +35,6 @@ export declare class Channel extends Emitter<ChannelEvent> {
     broadcast<K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], 'timestamp'>, callback?: Function): void;
     sendMetadata(metadata: Metadata): void;
     sendPresenceJoined(): void;
+    onOnlineHandler: () => void;
     disconnect(): void;
 }

package/dist/types/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/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/connectivity/singleton.d.ts

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

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

@@ -13,3 +13,4 @@ export declare enum DisconnectReason {
     SOCKET_TIMEOUT = "SOCKET_TIMEOUT",
     UNKNOWN_DISCONNECT = "UNKNOWN_DISCONNECT"
 }
+export declare const disconnectedReasonMapper: (reason: string) => DisconnectReason;

package/dist/types/{error-code-mapper.d.ts → errors/error-code-mapper.d.ts}

@@ -1,4 +1,4 @@
-import type { CollabErrorPayload, ErrorPayload } from './types';
+import type { CollabErrorPayload, ErrorPayload } from '../types';
 export declare const ErrorCodeMapper: {
     noPermissionError: {
         code: string;
@@ -24,9 +24,13 @@ export declare const ErrorCodeMapper: {
         code: string;
         message: string;
     };
+    restoreError: {
+        code: string;
+        message: string;
+    };
     internalError: {
         code: string;
         message: string;
     };
 };
-export declare const errorCodeMapper: (error: ErrorPayload) => CollabErrorPayload;
+export declare const errorCodeMapper: (error: ErrorPayload) => CollabErrorPayload | undefined;

package/dist/types/errors/error-types.d.ts

@@ -0,0 +1,8 @@
+export declare class NotConnectedError extends Error {
+    name: string;
+    constructor(message: string);
+}
+export declare class NotInitializedError extends Error {
+    name: string;
+    constructor(message: string);
+}

package/dist/types/helpers/const.d.ts

@@ -1,20 +1,16 @@
-import { CollabErrorPayload, ErrorPayload } from '../types';
-export declare const EVENT_SUBJECT = "collab";
-export declare enum COLLAB_SERVICE {
-    NCS = "ncs",
-    SYNCHRONY = "synchrony"
-}
+import type { CollabErrorPayload } from '../types';
 export declare enum EVENT_ACTION {
     CONNECTION = "connection",
     CATCHUP = "catchup",
     DOCUMENT_INIT = "documentInit",
     ADD_STEPS = "addSteps",
-    CONVERT_PM_TO_ADF = "convertPMToADF",
     UPDATE_PARTICIPANTS = "updateParticipants",
     COMMIT_UNCONFIRMED_STEPS = "commitUnconfirmedSteps",
     REINITIALISE_DOCUMENT = "reinitialiseDocument",
-    INIT_PROVIDER = "initProvider",
-    ERROR = "error"
+    ERROR = "error",
+    PUBLISH_PAGE = "publishPage",
+    GET_CURRENT_STATE = "getCurrentState",
+    INVALIDATE_TOKEN = "invalidateToken"
 }
 export declare enum EVENT_STATUS {
     SUCCESS = "SUCCESS",
@@ -25,12 +21,32 @@ export declare enum ADD_STEPS_TYPE {
     REJECTED = "REJECTED",
     ERROR = "ERROR"
 }
+export declare type ErrorAnalyticsEvent = {
+    eventAction: EVENT_ACTION.ERROR;
+    attributes: {
+        errorMessage: string;
+        errorName?: string;
+        documentAri?: string;
+        mappedError?: CollabErrorPayload;
+    };
+    nonPrivacySafeAttributes: {
+        error: unknown;
+    };
+};
+declare type InvalidateTokenAnalyticsEvent = {
+    eventAction: EVENT_ACTION.INVALIDATE_TOKEN;
+    attributes: {
+        eventStatus: EVENT_STATUS.SUCCESS;
+        reason?: string;
+        usedCachedToken?: boolean;
+    };
+};
 declare type AddStepsSuccessAnalyticsEvent = {
     eventAction: EVENT_ACTION.ADD_STEPS;
     attributes: {
+        documentAri: string;
         eventStatus: EVENT_STATUS.SUCCESS;
         type: ADD_STEPS_TYPE.ACCEPTED;
-        documentAri: string;
         latency?: number;
         stepType?: {
             [key: string]: number;
@@ -40,38 +56,129 @@ declare type AddStepsSuccessAnalyticsEvent = {
 declare type AddStepsFailureAnalyticsEvent = {
     eventAction: EVENT_ACTION.ADD_STEPS;
     attributes: {
+        documentAri: string;
         eventStatus: EVENT_STATUS.FAILURE;
         type: ADD_STEPS_TYPE.REJECTED | ADD_STEPS_TYPE.ERROR;
+        latency?: number;
+    };
+};
+declare type ReInitDocFailAnalyticsEvent = {
+    eventAction: EVENT_ACTION.REINITIALISE_DOCUMENT;
+    attributes: {
         documentAri: string;
+        eventStatus: EVENT_STATUS.FAILURE;
+        numUnconfirmedSteps: number;
+    };
+};
+declare type ReInitDocSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.REINITIALISE_DOCUMENT;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        numUnconfirmedSteps: number;
+    };
+};
+declare type ConnectionSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.CONNECTION;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
         latency?: number;
-        error: ErrorPayload;
     };
 };
-declare type ErrorAnalyticsEvent = {
-    eventAction: EVENT_ACTION.ERROR;
+declare type ConnectionFailureAnalyticsEvent = {
+    eventAction: EVENT_ACTION.CONNECTION;
     attributes: {
-        attemptedAction?: EVENT_ACTION;
         documentAri: string;
-        mappedError?: CollabErrorPayload;
+        eventStatus: EVENT_STATUS.FAILURE;
+        latency?: number;
     };
-    nonPrivacySafeAttributes: {
-        error: ErrorPayload;
+};
+declare type CatchUpSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.CATCHUP;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        latency?: number;
+    };
+};
+declare type CatchUpFailureAnalyticsEvent = {
+    eventAction: EVENT_ACTION.CATCHUP;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.FAILURE;
+        latency?: number;
     };
 };
-export declare type AnalyticsEvent = {
-    eventAction: EVENT_ACTION.CONNECTION | EVENT_ACTION.CATCHUP | EVENT_ACTION.DOCUMENT_INIT | EVENT_ACTION.CONVERT_PM_TO_ADF | EVENT_ACTION.UPDATE_PARTICIPANTS | EVENT_ACTION.COMMIT_UNCONFIRMED_STEPS | EVENT_ACTION.REINITIALISE_DOCUMENT;
+declare type DocumentInitSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.DOCUMENT_INIT;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        latency?: number;
+        resetReason?: string;
+        ttlEnabled?: boolean;
+    };
+};
+declare type UpdateParticipantsSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.UPDATE_PARTICIPANTS;
     attributes: {
         documentAri?: string;
-        eventStatus?: EVENT_STATUS;
-        meetsSLO?: boolean;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        participants: number;
+    };
+};
+declare type CommitUnconfirmedStepsSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.COMMIT_UNCONFIRMED_STEPS;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
         latency?: number;
-        error?: ErrorPayload;
-        participants?: number;
         numUnconfirmedSteps?: number;
-        requiredPageRecovery?: boolean;
-        ttlEnabled?: boolean;
     };
-} | AddStepsSuccessAnalyticsEvent | AddStepsFailureAnalyticsEvent | ErrorAnalyticsEvent;
+};
+declare type CommitUnconfirmedStepsFailureAnalyticsEvent = {
+    eventAction: EVENT_ACTION.COMMIT_UNCONFIRMED_STEPS;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.FAILURE;
+        latency?: number;
+        numUnconfirmedSteps?: number;
+    };
+};
+declare type PublishPageSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.PUBLISH_PAGE;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        latency?: number;
+    };
+};
+declare type PublishPageFailureAnalyticsEvent = {
+    eventAction: EVENT_ACTION.PUBLISH_PAGE;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.FAILURE;
+        latency?: number;
+    };
+};
+declare type GetCurrentStateSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.GET_CURRENT_STATE;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        latency?: number;
+    };
+};
+declare type GetCurrentStateFailureAnalyticsEvent = {
+    eventAction: EVENT_ACTION.GET_CURRENT_STATE;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.FAILURE;
+        latency?: number;
+    };
+};
+export declare type ActionAnalyticsEvent = AddStepsSuccessAnalyticsEvent | AddStepsFailureAnalyticsEvent | ReInitDocFailAnalyticsEvent | ReInitDocSuccessAnalyticsEvent | ConnectionSuccessAnalyticsEvent | ConnectionFailureAnalyticsEvent | CatchUpSuccessAnalyticsEvent | CatchUpFailureAnalyticsEvent | DocumentInitSuccessAnalyticsEvent | UpdateParticipantsSuccessAnalyticsEvent | CommitUnconfirmedStepsSuccessAnalyticsEvent | CommitUnconfirmedStepsFailureAnalyticsEvent | PublishPageSuccessAnalyticsEvent | PublishPageFailureAnalyticsEvent | GetCurrentStateSuccessAnalyticsEvent | GetCurrentStateFailureAnalyticsEvent | InvalidateTokenAnalyticsEvent;
 export declare const ACK_MAX_TRY = 30;
 export declare const CONFLUENCE = "confluence";
 export {};

package/dist/types/provider/commit-step.d.ts

@@ -0,0 +1,14 @@
+import { ErrorPayload, StepsPayload } from '../types';
+import type { Step as ProseMirrorStep } from 'prosemirror-transform';
+import type { Channel } from '../channel';
+import AnalyticsHelper from '../analytics';
+export declare const commitStep: ({ channel, steps, version, userId, clientId, onStepsAdded, onErrorHandled, analyticsHelper, }: {
+    channel: Channel;
+    steps: readonly ProseMirrorStep[];
+    version: number;
+    userId: string;
+    clientId: number | string;
+    onStepsAdded: (data: StepsPayload) => void;
+    onErrorHandled: (error: ErrorPayload) => void;
+    analyticsHelper?: AnalyticsHelper | undefined;
+}) => void;

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

@@ -1,11 +1,28 @@
+/// <reference types="lodash" />
 import type { EditorState, Transaction } from 'prosemirror-state';
+import type { Step as ProseMirrorStep } from 'prosemirror-transform';
 import { Emitter } from '../emitter';
-import type { CollabEditProvider, ResolvedEditorState } from '@atlaskit/editor-common/collab';
-import type { CollabEvents, Config, Metadata } from '../types';
+import { Channel } from '../channel';
+import type { CollabEditProvider, CollabParticipant, ResolvedEditorState } from '@atlaskit/editor-common/collab';
+import type { CollabEvents, Config, ErrorPayload, Metadata, StepsPayload } from '../types';
+import AnalyticsHelper from '../analytics';
 import type { SyncUpErrorFunction } from '@atlaskit/editor-common/types';
-export declare const CATCHUP_THROTTLE: number;
 export declare const MAX_STEP_REJECTED_ERROR = 15;
+export declare const throttledCommitStep: import("lodash").DebouncedFunc<({ channel, steps, version, userId, clientId, onStepsAdded, onErrorHandled, analyticsHelper, }: {
+    channel: Channel;
+    steps: readonly ProseMirrorStep<any>[];
+    version: number;
+    userId: string;
+    clientId: string | number;
+    onStepsAdded: (data: StepsPayload) => void;
+    onErrorHandled: (error: ErrorPayload) => void;
+    analyticsHelper?: AnalyticsHelper | undefined;
+}) => void>;
 declare type BaseEvents = Pick<CollabEditProvider<CollabEvents>, 'setup' | 'send' | 'sendMessage'>;
+export declare type ParticipantsMap = Map<string, CollabParticipant & {
+    userId: string;
+    clientId: number | string;
+}>;
 export declare class Provider extends Emitter<CollabEvents> implements BaseEvents {
     private participants;
     private channel;
@@ -13,7 +30,7 @@ export declare class Provider extends Emitter<CollabEvents> implements BaseEvent
     private getState;
     private metadata;
     private stepRejectCounter;
-    private analyticsClient?;
+    private analyticsHelper?;
     private isChannelInitialized;
     private isNamespaceLocked;
     private onSyncUpError?;
@@ -58,6 +75,7 @@ export declare class Provider extends Emitter<CollabEvents> implements BaseEvent
     private applyLocalSteps;
     private getCurrentPmVersion;
     private getUnconfirmedSteps;
+    private getUnconfirmedStepsOrigins;
     /**
      * Called when:
      *   * session established(offline -> online)
@@ -66,7 +84,6 @@ export declare class Provider extends Emitter<CollabEvents> implements BaseEvent
     private catchup;
     /**
      * @param error - The error to handle
-     * @param disableAnalytics - If analytics is already dispatched for this error, re-sending it here can be disabled
      */
     private onErrorHandled;
     private pauseQueue?;
@@ -115,13 +132,14 @@ export declare class Provider extends Emitter<CollabEvents> implements BaseEvent
      */
     private updateParticipants;
     private emitTelepointersFromSteps;
-    private disconnectedReasonMapper;
     private onDisconnected;
     destroy(): this;
     disconnect(): this;
     setTitle(title: string, broadcast?: boolean): void;
     setEditorWidth(editorWidth: string, broadcast?: boolean): void;
     setMetadata(metadata: Metadata): void;
+    getCurrentState: () => Promise<ResolvedEditorState>;
+    private commitUnconfirmedSteps;
     getFinalAcknowledgedState: () => Promise<ResolvedEditorState>;
     /**
      * Unsubscribe from all events emitted by this provider.

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

@@ -0,0 +1,5 @@
+import type { CollabEventTelepointerData } from '@atlaskit/editor-common/collab';
+import { AcknowledgementPayload, StepJson } from '../types';
+import { ParticipantsMap } from './index';
+export declare const telepointersFromStep: (participants: ParticipantsMap, step: StepJson) => CollabEventTelepointerData | undefined;
+export declare const telepointerCallback: (documentAri: string) => (response: AcknowledgementPayload) => void;

package/dist/types/socket-io-provider.d.ts

@@ -1,4 +1,5 @@
 import { Provider } from './provider';
-import { Socket, Config, ProductInformation } from './types';
-export declare function createSocketIOSocket(url: string, auth?: (cb: (data: object) => void) => void, productInfo?: ProductInformation): Socket;
+import { Socket } from 'socket.io-client';
+import { Config, ProductInformation, InitAndAuthData, AuthCallback } from './types';
+export declare function createSocketIOSocket(url: string, auth?: AuthCallback | InitAndAuthData, productInfo?: ProductInformation): Socket;
 export declare function createSocketIOCollabProvider(config: Omit<Config, 'createSocket'>): Provider;

package/dist/types/types.d.ts

@@ -1,5 +1,5 @@
-import type { Transaction } from 'prosemirror-state';
-import type { Step } from 'prosemirror-transform';
+import type { Step as ProseMirrorStep } from 'prosemirror-transform';
+import type { Transaction as ProseMirrorTransaction } from 'prosemirror-state';
 import type { CollabParticipant, CollabEventTelepointerData, CollabEventConnectionData, CollabEventInitData, CollabEventRemoteData, CollabEventPresenceData, CollabEventConnectingData } from '@atlaskit/editor-common/collab';
 import type { AnalyticsWebClient } from '@atlaskit/analytics-listeners';
 import type { Manager } from 'socket.io-client';
@@ -15,7 +15,7 @@ export interface Config {
     lifecycle?: Lifecycle;
     storage?: Storage;
     need404?: boolean;
-    createSocket: (path: string, auth?: (cb: (data: object) => void) => void, productInfo?: ProductInformation) => Socket;
+    createSocket: (path: string, auth?: AuthCallback | InitAndAuthData, productInfo?: ProductInformation) => Socket;
     analyticsClient?: AnalyticsWebClient;
     featureFlags?: {
         [key: string]: boolean;
@@ -23,9 +23,24 @@ export interface Config {
     getUser?(userId: string): Promise<Pick<CollabParticipant, 'avatar' | 'email' | 'name'> & {
         userId: string;
     }>;
+    /**
+     * If provided, permissionTokenRefresh is called whenever a new JWT token is required.
+     */
     permissionTokenRefresh?: () => Promise<string | null>;
+    cacheToken?: boolean;
     productInfo?: ProductInformation;
+    /**
+     * Throws errors when trying to send data to collab but the client is not offline.
+     * This can lead to potential dataloss and retrying should be considered. Without this flag the provider silently drops the requests.
+     */
+    throwOnNotConnected?: boolean;
 }
+export interface InitAndAuthData {
+    initialized: boolean;
+    need404?: boolean;
+    token?: string;
+}
+export declare type AuthCallback = (cb: (data: InitAndAuthData) => void) => void;
 interface SimpleEventEmitter {
     on(event: string, fn: Function): SimpleEventEmitter;
 }
@@ -69,7 +84,7 @@ export declare type CollabTelepointerPayload = CollabEventTelepointerData;
 export declare type CollabPresencePayload = CollabEventPresenceData;
 export declare type CollabMetadataPayload = Metadata;
 export declare type CollabLocalStepsPayload = {
-    steps: readonly Step[];
+    steps: readonly ProseMirrorStep[];
 };
 export interface CollabEvents {
     'metadata:changed': CollabMetadataPayload;
@@ -106,10 +121,31 @@ export declare type TelepointerPayload = PresencePayload & {
         head: number;
     };
 };
+declare type MarkJson = {
+    type: string;
+    attrs: {
+        [key: string]: any;
+    };
+};
+declare type NodeJson = {
+    type: string;
+    attrs: {
+        [key: string]: any;
+    };
+    content: NodeJson[];
+    marks: MarkJson[];
+    text?: string;
+};
+declare type SliceJson = {
+    content: NodeJson[];
+    openStart: number;
+    openEnd: number;
+};
 export declare type StepJson = {
+    stepType?: string;
     from?: number;
     to?: number;
-    stepType?: string;
+    slice?: SliceJson;
     clientId: number | string;
     userId: string;
     createdAt?: number;
@@ -186,14 +222,10 @@ export interface CatchupOptions {
     getCurrentPmVersion: () => number;
     fetchCatchup: (fromVersion: number) => Promise<CatchupResponse>;
     filterQueue: (condition: (stepsPayload: StepsPayload) => boolean) => void;
-    getUnconfirmedSteps: () => {
-        version: number;
-        steps: readonly Step<any>[];
-        clientID: string | number;
-        origins: readonly Transaction<any>[];
-    } | null | undefined;
+    getUnconfirmedSteps: () => readonly ProseMirrorStep[] | undefined;
+    getUnconfirmedStepsOrigins: () => readonly ProseMirrorTransaction[] | undefined;
     updateDocumentWithMetadata: ({ doc, version, metadata, reserveCursor, }: CollabInitPayload) => void;
-    applyLocalSteps: (steps: Step[]) => void;
+    applyLocalSteps: (steps: ProseMirrorStep[]) => void;
 }
 export declare type ProductInformation = {
     product: string;