@atlaskit/collab-provider 11.3.1 → 11.3.2

package/dist/types-ts4.5/helpers/const.d.ts

@@ -37,29 +37,29 @@ export declare enum ADD_STEPS_TYPE {
     ERROR = "ERROR"
 }
 export type DocumentUpdateErrorAttributes = {
-    isDocTruthy?: boolean;
-    editorVersion?: number;
-    newVersion?: number;
+    caller?: string;
     docHasContent?: boolean;
+    editorVersion?: number;
     isDocContentValid?: boolean;
-    caller?: string;
+    isDocTruthy?: boolean;
+    newVersion?: number;
 };
 export type CantSyncUpErrorAttributes = {
     unconfirmedStepsInfo: string;
 };
 export type ErrorAnalyticsEvent = {
-    eventAction: EVENT_ACTION.ERROR;
     attributes: {
+        documentAri?: string;
+        errorCode?: string;
         errorMessage: string;
-        originalErrorMessage: string | undefined;
         errorName?: string;
-        errorCode?: string;
-        errorStatus?: string;
         errorStack?: string;
-        documentAri?: string;
+        errorStatus?: string;
         mappedError?: ProviderError;
+        originalErrorMessage: string | undefined;
         subProduct?: string;
     } & DocumentUpdateErrorAttributes;
+    eventAction: EVENT_ACTION.ERROR;
     nonPrivacySafeAttributes?: {
         error: unknown;
     };
@@ -69,247 +69,247 @@ export type BaseActionAnalyticsEventAttributes = {
     subProduct?: string;
 };
 type InvalidateTokenAnalyticsEvent = {
-    eventAction: EVENT_ACTION.INVALIDATE_TOKEN;
     attributes: {
         eventStatus: EVENT_STATUS.SUCCESS;
         reason?: string;
         usedCachedToken?: boolean;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.INVALIDATE_TOKEN;
 };
 type AddStepsSuccessAnalyticsEvent = {
-    eventAction: EVENT_ACTION.ADD_STEPS;
     attributes: {
         eventStatus: EVENT_STATUS.SUCCESS;
-        type: ADD_STEPS_TYPE.ACCEPTED;
         latency?: number;
         stepType?: {
             [key: string]: number;
         };
+        type: ADD_STEPS_TYPE.ACCEPTED;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.ADD_STEPS;
 };
 type AddStepsFailureAnalyticsEvent = {
-    eventAction: EVENT_ACTION.ADD_STEPS;
     attributes: {
         eventStatus: EVENT_STATUS.FAILURE;
-        type: ADD_STEPS_TYPE.REJECTED | ADD_STEPS_TYPE.ERROR;
         latency?: number;
+        type: ADD_STEPS_TYPE.REJECTED | ADD_STEPS_TYPE.ERROR;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.ADD_STEPS;
 };
 type ReInitDocFailAnalyticsEvent = {
-    eventAction: EVENT_ACTION.REINITIALISE_DOCUMENT;
     attributes: {
         eventStatus: EVENT_STATUS.FAILURE;
         numUnconfirmedSteps: number;
         triggeredByCatchup?: boolean;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.REINITIALISE_DOCUMENT;
 };
 type ReInitDocSuccessAnalyticsEvent = {
-    eventAction: EVENT_ACTION.REINITIALISE_DOCUMENT;
     attributes: {
         eventStatus: EVENT_STATUS.SUCCESS;
         numUnconfirmedSteps: number;
         triggeredByCatchup?: boolean;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.REINITIALISE_DOCUMENT;
 };
 type ConnectionSuccessAnalyticsEvent = {
-    eventAction: EVENT_ACTION.CONNECTION;
     attributes: {
         eventStatus: EVENT_STATUS.SUCCESS;
         latency?: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.CONNECTION;
 };
 type ConnectionFailureAnalyticsEvent = {
-    eventAction: EVENT_ACTION.CONNECTION;
     attributes: {
         eventStatus: EVENT_STATUS.FAILURE;
         latency?: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.CONNECTION;
 };
 type CatchUpSuccessAnalyticsEvent = {
-    eventAction: EVENT_ACTION.CATCHUP;
     attributes: {
         eventStatus: EVENT_STATUS.SUCCESS;
         latency?: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.CATCHUP;
 };
 type CatchUpFailureAnalyticsEvent = {
-    eventAction: EVENT_ACTION.CATCHUP;
     attributes: {
         eventStatus: EVENT_STATUS.FAILURE;
         latency?: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.CATCHUP;
 };
 type CatchUpDroppedStepsEvent = {
-    eventAction: EVENT_ACTION.DROPPED_STEPS;
     attributes: {
         numOfDroppedSteps: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.DROPPED_STEPS;
 };
 type DocumentInitSuccessAnalyticsEvent = {
-    eventAction: EVENT_ACTION.DOCUMENT_INIT;
     attributes: {
         eventStatus: EVENT_STATUS.SUCCESS;
+        hasTitle: boolean;
         latency?: number;
         resetReason?: string;
-        hasTitle: boolean;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.DOCUMENT_INIT;
 };
 type UpdateParticipantsSuccessAnalyticsEvent = {
-    eventAction: EVENT_ACTION.UPDATE_PARTICIPANTS;
     attributes: {
         eventStatus: EVENT_STATUS.SUCCESS;
         participants: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.UPDATE_PARTICIPANTS;
 };
 type CommitUnconfirmedStepsSuccessAnalyticsEvent = {
-    eventAction: EVENT_ACTION.COMMIT_UNCONFIRMED_STEPS;
     attributes: {
         eventStatus: EVENT_STATUS.SUCCESS;
         latency?: number;
         numUnconfirmedSteps?: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.COMMIT_UNCONFIRMED_STEPS;
 };
 type CommitUnconfirmedStepsFailureAnalyticsEvent = {
-    eventAction: EVENT_ACTION.COMMIT_UNCONFIRMED_STEPS;
     attributes: {
         eventStatus: EVENT_STATUS.FAILURE;
         latency?: number;
         numUnconfirmedSteps?: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.COMMIT_UNCONFIRMED_STEPS;
 };
 type PublishPageSuccessAnalyticsEvent = {
-    eventAction: EVENT_ACTION.PUBLISH_PAGE;
     attributes: {
         eventStatus: EVENT_STATUS.SUCCESS;
         latency?: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.PUBLISH_PAGE;
 };
 type PublishPageFailureAnalyticsEvent = {
-    eventAction: EVENT_ACTION.PUBLISH_PAGE;
     attributes: {
         eventStatus: EVENT_STATUS.FAILURE;
         latency?: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.PUBLISH_PAGE;
 };
 type GetCurrentStateSuccessAnalyticsEvent = {
-    eventAction: EVENT_ACTION.GET_CURRENT_STATE;
     attributes: {
         eventStatus: EVENT_STATUS.SUCCESS;
         latency?: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.GET_CURRENT_STATE;
 };
 type GetCurrentStateFailureAnalyticsEvent = {
-    eventAction: EVENT_ACTION.GET_CURRENT_STATE;
     attributes: {
         eventStatus: EVENT_STATUS.FAILURE;
         latency?: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.GET_CURRENT_STATE;
 };
 type SendStepsRetryAnalyticsEvent = {
-    eventAction: EVENT_ACTION.SEND_STEPS_RETRY;
     attributes: {
-        eventStatus: EVENT_STATUS.INFO;
         count: number;
+        eventStatus: EVENT_STATUS.INFO;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.SEND_STEPS_RETRY;
 };
 type CatchupAfterMaxSendStepsRetryAnalyticsEvent = {
-    eventAction: EVENT_ACTION.CATCHUP_AFTER_MAX_SEND_STEPS_RETRY;
     attributes: {
         eventStatus: EVENT_STATUS.INFO;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.CATCHUP_AFTER_MAX_SEND_STEPS_RETRY;
 };
 type WebsocketMessageVolumeMetricEvent = {
-    eventAction: EVENT_ACTION.WEBSOCKET_MESSAGE_VOLUME_METRIC;
     attributes: {
         eventStatus: EVENT_STATUS.INFO;
         messageCount: number;
         messageSize: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.WEBSOCKET_MESSAGE_VOLUME_METRIC;
 };
 type ProviderInitializedAnalyticsEvent = {
-    eventAction: EVENT_ACTION.PROVIDER_INITIALIZED;
     attributes: {
         eventStatus: EVENT_STATUS.INFO;
-        isPreinitializing: boolean;
         isBuffered?: boolean;
+        isPreinitializing: boolean;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.PROVIDER_INITIALIZED;
 };
 type ProviderSetupAnalyticsEvent = {
-    eventAction: EVENT_ACTION.PROVIDER_SETUP;
     attributes: {
         eventStatus: EVENT_STATUS.INFO;
-        isPreinitializing: boolean;
         hasState: boolean;
+        isPreinitializing: boolean;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.PROVIDER_SETUP;
 };
 type ProviderHasUnconfirmedStepsAnalyticsEvent = {
-    eventAction: EVENT_ACTION.HAS_UNCONFIRMED_STEPS;
     attributes: {
         numUnconfirmedSteps: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.HAS_UNCONFIRMED_STEPS;
 };
 type UpdateDocumentAnalyticsEvent = {
-    eventAction: EVENT_ACTION.UPDATE_DOCUMENT;
     attributes: {
-        eventStatus: EVENT_STATUS.SUCCESS;
-        newVersion: number;
-        editorVersion: number;
-        isDocTruthy: boolean;
         docHasContent: boolean;
+        editorVersion: number;
+        eventStatus: EVENT_STATUS.SUCCESS;
         isDocContentValid: boolean;
+        isDocTruthy: boolean;
+        newVersion: number;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.UPDATE_DOCUMENT;
 };
 type ReconnectionAnalyticsEvent = {
-    eventAction: EVENT_ACTION.RECONNECTION;
     attributes: {
-        eventStatus: EVENT_STATUS.SUCCESS;
         disconnectionPeriodSeconds: number;
+        eventStatus: EVENT_STATUS.SUCCESS;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.RECONNECTION;
 };
 type OutOfSyncAnalyticsEvent = {
-    eventAction: EVENT_ACTION.OUT_OF_SYNC;
     attributes: {
+        catchupReason: CatchupEventReason | undefined;
         eventStatus: EVENT_STATUS.FAILURE;
-        obfuscatedSteps: {
-            [key: string]: number;
-        }[];
         obfuscatedDoc: {
             [key: string]: number;
         };
-        catchupReason: CatchupEventReason | undefined;
+        obfuscatedSteps: {
+            [key: string]: number;
+        }[];
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.OUT_OF_SYNC;
 };
 type StepsRebasedAnalyticsEvent = {
-    eventAction: EVENT_ACTION.STEPS_REBASED;
     attributes: {
+        clientID: 'string';
         eventStatus: EVENT_STATUS.INFO;
-        obfuscatedUnconfirmedSteps: {
+        obfuscatedRebasedSteps: {
             [key: string]: number;
         }[];
         obfuscatedRemoteSteps: {
             [key: string]: number;
         }[];
-        obfuscatedRebasedSteps: {
+        obfuscatedUnconfirmedSteps: {
             [key: string]: number;
         }[];
-        clientID: 'string';
         userId: 'string';
-        versionBefore: 'string';
         versionAfter: 'string';
+        versionBefore: 'string';
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.STEPS_REBASED;
 };
 type PollingFallbackAnalyticsEvent = {
-    eventAction: EVENT_ACTION.POLLING_FALLBACK;
     attributes: {
         eventStatus: EVENT_STATUS.INFO;
         url: 'string';
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.POLLING_FALLBACK;
 };
 type ProcessStepsAnalyticsEvent = {
-    eventAction: EVENT_ACTION.PROCESS_STEPS;
     attributes: {
         eventStatus: EVENT_STATUS.SUCCESS;
     } & BaseActionAnalyticsEventAttributes;
+    eventAction: EVENT_ACTION.PROCESS_STEPS;
 };
 export type ActionAnalyticsEvent = AddStepsSuccessAnalyticsEvent | AddStepsFailureAnalyticsEvent | ReInitDocFailAnalyticsEvent | ReInitDocSuccessAnalyticsEvent | ConnectionSuccessAnalyticsEvent | ConnectionFailureAnalyticsEvent | CatchUpSuccessAnalyticsEvent | CatchUpFailureAnalyticsEvent | DocumentInitSuccessAnalyticsEvent | UpdateParticipantsSuccessAnalyticsEvent | CommitUnconfirmedStepsSuccessAnalyticsEvent | CommitUnconfirmedStepsFailureAnalyticsEvent | PublishPageSuccessAnalyticsEvent | PublishPageFailureAnalyticsEvent | GetCurrentStateSuccessAnalyticsEvent | GetCurrentStateFailureAnalyticsEvent | InvalidateTokenAnalyticsEvent | SendStepsRetryAnalyticsEvent | CatchupAfterMaxSendStepsRetryAnalyticsEvent | CatchUpDroppedStepsEvent | WebsocketMessageVolumeMetricEvent | ProviderInitializedAnalyticsEvent | ProviderSetupAnalyticsEvent | ProviderHasUnconfirmedStepsAnalyticsEvent | UpdateDocumentAnalyticsEvent | ReconnectionAnalyticsEvent | OutOfSyncAnalyticsEvent | StepsRebasedAnalyticsEvent | PollingFallbackAnalyticsEvent | ProcessStepsAnalyticsEvent;
 export declare const ACK_MAX_TRY = 60;

package/dist/types-ts4.5/helpers/utils.d.ts

@@ -12,9 +12,9 @@ export declare const isAIProviderID: (id: string) => boolean;
 export declare const getProduct: (productInfo?: ProductInformation) => string;
 export declare const getSubProduct: (productInfo?: ProductInformation) => string;
 export type UGCFreeStepDetails = {
-    type: string;
     contentTypes: string;
     stepSizeInBytes?: number;
+    type: string;
 };
 export declare const getStepUGCFreeDetails: (step: ProseMirrorStep) => UGCFreeStepDetails;
 export declare const getStepTypes: (stepJson: StepJson) => {
@@ -47,13 +47,13 @@ export declare const getObfuscatedSteps: (steps: StepJson[], endIndex?: number |
         to?: number | undefined;
     };
     stepMetadata: {
-        source?: string;
-        stepId?: string;
         prevStepId?: string;
         rebased?: boolean;
-        traceId?: string;
         reqId?: string;
         schemaVersion?: string;
+        source?: string;
+        stepId?: string;
+        traceId?: string;
         unconfirmedStepAfterRecovery?: boolean;
     } | undefined;
 }[];

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

@@ -50,12 +50,12 @@ export declare class ParticipantsService {
     constructor(analyticsHelper: AnalyticsHelper | undefined, participantsState: ParticipantsState | undefined, emit: (evt: 'presence' | 'telepointer' | 'disconnected' | 'presence:changed', data: CollabEventPresenceData | CollabTelepointerPayload | CollabEventDisconnectedData | CollabPresenceActivityChangePayload) => void, getUser: GetUserType, batchProps: BatchProps | undefined, channelBroadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], 'timestamp'>, callback?: Function) => void, sendPresenceJoined: () => void, getPresenceData: () => PresenceData, setUserId: (id: string) => void, getAIProviderActiveIds?: (() => string[]) | undefined, fetchAnonymousAsset?: FetchAnonymousAsset | undefined);
     sendPresenceActivityChanged: () => void;
     sendAIProviderChanged: (payload: {
-        userId: string;
-        sessionId: string;
-        clientId: string | number;
-        providerId?: string;
         action: "add" | "remove";
+        clientId: string | number;
         permit?: UserPermitType;
+        providerId?: string;
+        sessionId: string;
+        userId: string;
     }) => void;
     private buildAIProviderPresencePayload;
     private sendAIProviderParticipantUpdated;

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

@@ -21,16 +21,16 @@ export declare class CommitStepService {
      */
     constructor(broadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], 'timestamp'>, callback?: Function) => void, analyticsHelper: AnalyticsHelper | undefined, emit: (evt: keyof CollabEvents, data: any) => void, onErrorHandled: (error: InternalError) => void);
     commitStepQueue({ steps, version, userId, clientId, onStepsAdded, __livePage, hasRecovered, collabMode, reason, lockSteps, }: {
-        steps: readonly ProseMirrorStep[];
-        version: number;
-        userId: string;
-        clientId: number | string;
-        onStepsAdded: (data: StepsPayload) => void;
         __livePage: boolean;
-        hasRecovered: boolean;
+        clientId: number | string;
         collabMode: string;
-        reason?: GetResolvedEditorStateReason;
+        hasRecovered: boolean;
         lockSteps: (stepOrigins?: readonly Transaction[]) => void;
+        onStepsAdded: (data: StepsPayload) => void;
+        reason?: GetResolvedEditorStateReason;
+        steps: readonly ProseMirrorStep[];
+        userId: string;
+        version: number;
     }): void;
     private isExpandChangeStep;
     private sendSuccessAnalytics;

package/dist/types-ts4.5/provider/index.d.ts

@@ -67,8 +67,8 @@ export declare class Provider extends Emitter<CollabEvents> implements BaseEvent
      * @throws {ProviderInitialisationError} Something went wrong during provider initialisation
      */
     setup({ getState, editorApi, onSyncUpError, }: {
-        getState: () => EditorState;
         editorApi?: any;
+        getState: () => EditorState;
         onSyncUpError?: SyncUpErrorFunction;
     }): this;
     setupForPresenceOnly(clientId: string): this;