@atlaskit/collab-provider 11.3.1 → 11.3.2

package/dist/types/types.d.ts

@@ -9,61 +9,77 @@ import type { StepJson, CollabSendableSelection, Metadata, UserPermitType, Prese
 import { type CatchupEventReason } from './helpers/const';
 import type { EditorState } from '@atlaskit/editor-prosemirror/state';
 export interface CollabEventDisconnectedData {
-    sid: string;
     reason: 'CLIENT_DISCONNECT' | 'SERVER_DISCONNECT' | 'SOCKET_CLOSED' | 'SOCKET_ERROR' | 'SOCKET_TIMEOUT' | 'UNKNOWN_DISCONNECT';
+    sid: string;
 }
 export interface Storage {
+    delete: (key: string) => Promise<void>;
     get: (key: string) => Promise<string>;
     set: (key: string, value: string) => Promise<void>;
-    delete: (key: string) => Promise<void>;
 }
 export interface InitialDraft {
     document: JSONDocNode;
-    version: number;
     metadata?: Metadata;
+    version: number;
 }
 export type FetchAnonymousAsset = (presenceId: string | undefined) => Promise<AnonymousAsset | undefined>;
 export interface Config {
-    url: string;
-    documentAri: string;
-    lifecycle?: Lifecycle;
-    storage?: Storage;
-    need404?: boolean;
-    createSocket: (path: string, auth?: AuthCallback | InitAndAuthData, productInfo?: ProductInformation, isPresenceOnly?: boolean, analyticsHelper?: AnalyticsHelper) => SocketIOSocket;
-    batchProps?: BatchProps;
-    fetchAnonymousAsset?: FetchAnonymousAsset;
+    /**
+     * There is expected to be temporary divergence between Live Page editor expand behaviour and the standard expand behaviour.
+     *
+     * This is expected to be removed in Q4 as Editor and Live Page teams align on a singular behaviour.
+     *
+     * It is only supported for use by Confluence.
+     *
+     * @default false
+     */
+    __livePage?: boolean;
     /**
      * @deprecated: Use promise based getAnalyticsWebClient instead
      */
     analyticsClient?: AnalyticsWebClient;
-    getAnalyticsWebClient?: Promise<AnalyticsWebClient>;
+    batchProps?: BatchProps;
+    createSocket: (path: string, auth?: AuthCallback | InitAndAuthData, productInfo?: ProductInformation, isPresenceOnly?: boolean, analyticsHelper?: AnalyticsHelper) => SocketIOSocket;
+    documentAri: string;
+    /**
+     * Enable checking if a document update from collab-provider is being dropped by the editor,
+     * throwing a non-recoverable error if it's detected.
+     */
+    enableErrorOnFailedDocumentApply?: boolean;
+    /**
+     * When a page is being published this number can control the number of failed steps until a catchup is triggered.
+     * The default value is MAX_STEP_REJECTED_ERROR (15).
+     */
+    failedStepLimitBeforeCatchupOnPublish?: number;
     featureFlags?: {
         [key: string]: boolean;
     };
+    fetchAnonymousAsset?: FetchAnonymousAsset;
+    getAnalyticsWebClient?: Promise<AnalyticsWebClient>;
     getUser?: GetUserType;
+    initialDraft?: InitialDraft;
+    isBufferingEnabled?: boolean;
+    isPresenceOnly?: boolean;
+    lifecycle?: Lifecycle;
+    need404?: boolean;
     /**
      * If provided, permissionTokenRefresh is called whenever a new JWT token is required.
      */
     permissionTokenRefresh?: () => Promise<string | null>;
-    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;
-    initialDraft?: InitialDraft;
-    isBufferingEnabled?: boolean;
-    isPresenceOnly?: boolean;
     /**
-     * When a page is being published this number can control the number of failed steps until a catchup is triggered.
-     * The default value is MAX_STEP_REJECTED_ERROR (15).
+     * Configure the provider to pass along a default activity during presence events. This activity will be used
+     * to display a user's activity, such as 'viewer' or 'editor'.
+     *
+     * This activity can be updated later on by the participants-service.
      */
-    failedStepLimitBeforeCatchupOnPublish?: number;
+    presenceActivity?: PresenceActivity;
     /**
-     * Enable checking if a document update from collab-provider is being dropped by the editor,
-     * throwing a non-recoverable error if it's detected.
+     * Configure the provider to pass along a persistent presenceId during presence events. This presenceId will be used
+     * to calculate the colors of the presence avatars as well as the editors telepointers. Since these two features are split across
+     * multiple websocket connections, the presenceId is used to correlate the two.
      */
-    enableErrorOnFailedDocumentApply?: boolean;
+    presenceId?: string;
+    productInfo?: ProductInformation;
     /**
      * Configure the client side circuit breaker in the event that abnormal behaviour causes the client to flood
      * NCS with too many steps or too large a volume of data. This can result in either a soft fail or a hard (fatal) fail
@@ -73,29 +89,13 @@ export interface Config {
     rateLimitStepCount?: number;
     rateLimitTotalStepSize?: number;
     rateLimitType?: number;
+    storage?: Storage;
     /**
-     * There is expected to be temporary divergence between Live Page editor expand behaviour and the standard expand behaviour.
-     *
-     * This is expected to be removed in Q4 as Editor and Live Page teams align on a singular behaviour.
-     *
-     * It is only supported for use by Confluence.
-     *
-     * @default false
-     */
-    __livePage?: boolean;
-    /**
-     * Configure the provider to pass along a persistent presenceId during presence events. This presenceId will be used
-     * to calculate the colors of the presence avatars as well as the editors telepointers. Since these two features are split across
-     * multiple websocket connections, the presenceId is used to correlate the two.
-     */
-    presenceId?: string;
-    /**
-     * Configure the provider to pass along a default activity during presence events. This activity will be used
-     * to display a user's activity, such as 'viewer' or 'editor'.
-     *
-     * This activity can be updated later on by the participants-service.
+     * 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.
      */
-    presenceActivity?: PresenceActivity;
+    throwOnNotConnected?: boolean;
+    url: string;
 }
 export interface InitAndAuthData {
     initialized: boolean;
@@ -107,10 +107,10 @@ interface SimpleEventEmitter {
     on: (event: string, fn: Function) => SimpleEventEmitter;
 }
 export interface Socket extends SimpleEventEmitter {
-    id: string;
+    close: () => Socket;
     connect: () => Socket;
     emit: (event: string, ...args: any[]) => Socket;
-    close: () => Socket;
+    id: string;
     io?: Manager;
 }
 export type LifecycleEvents = 'save' | 'restore';
@@ -120,10 +120,10 @@ export interface Lifecycle {
 }
 export type InitPayload = {
     doc: any;
-    version: number;
-    userId?: string;
     metadata?: Metadata;
     targetClientId?: string;
+    userId?: string;
+    version: number;
 };
 /**
  * @description Incoming payload type from the `broadcast` route in NCS
@@ -132,21 +132,21 @@ export type InitPayload = {
  * @param data event specific data from NCS
  */
 export type BroadcastIncomingPayload = {
+    data: PresencePayload | TelepointerPayload | StepsPayload | any;
     sessionId?: string;
     timestamp?: number;
-    data: PresencePayload | TelepointerPayload | StepsPayload | any;
 };
 export type PresenceData = {
-    sessionId: string;
-    userId: string | undefined;
     clientId: number | string;
     permit?: UserPermitType;
-    presenceId?: string;
     presenceActivity?: PresenceActivity;
+    presenceId?: string;
+    sessionId: string;
+    userId: string | undefined;
 };
 export type PresencePayload = PresenceData & {
-    timestamp: number;
     data?: Record<string, any>;
+    timestamp: number;
 };
 export type TelepointerPayload = PresencePayload & {
     selection: CollabSendableSelection;
@@ -160,19 +160,19 @@ export type AcknowledgementSuccessPayload = {
 };
 export type AcknowledgementPayload = AcknowledgementSuccessPayload | AcknowledgementErrorPayload;
 export type AddStepAcknowledgementSuccessPayload = {
+    delay?: number;
     type: AcknowledgementResponseTypes.SUCCESS;
     version: number;
-    delay?: number;
 };
 export type AcknowledgementErrorPayload = {
-    type: AcknowledgementResponseTypes.ERROR;
-    error: InternalError;
     delay?: number;
+    error: InternalError;
+    type: AcknowledgementResponseTypes.ERROR;
 };
 export type AddStepAcknowledgementPayload = AddStepAcknowledgementSuccessPayload | AcknowledgementErrorPayload;
 export type StepsPayload = {
-    version: number;
     steps: StepJson[];
+    version: number;
 };
 export type NamespaceStatus = {
     isLocked: boolean;
@@ -181,64 +181,64 @@ export type NamespaceStatus = {
 };
 export type ChannelEvent = {
     connected: {
-        sid: string;
         initialized: boolean;
+        sid: string;
     };
+    disconnect: {
+        reason: string;
+    };
+    error: InternalError;
     init: InitPayload;
-    restore: InitPayload;
-    reconnected: null;
-    'presence:joined': PresencePayload;
-    presence: PresencePayload;
+    'metadata:changed': Metadata;
     'participant:left': PresencePayload;
     'participant:telepointer': TelepointerPayload;
     'participant:updated': PresencePayload;
+    permission: UserPermitType;
+    presence: PresencePayload;
+    'presence:joined': PresencePayload;
+    reconnected: null;
+    restore: InitPayload;
+    status: NamespaceStatus;
+    'steps:added': StepsPayload;
     'steps:commit': StepsPayload & {
-        userId: string;
         collabMode: string;
         forcePublish?: boolean;
+        userId: string;
     };
-    'steps:added': StepsPayload;
-    'metadata:changed': Metadata;
-    permission: UserPermitType;
-    error: InternalError;
-    disconnect: {
-        reason: string;
-    };
-    status: NamespaceStatus;
 };
 export interface Catchupv2Response {
-    steps?: StepJson[];
     metadata?: Metadata;
+    steps?: StepJson[];
 }
 export interface ReconcileResponse {
-    document: string;
-    version: number;
     ari?: string;
+    document: string;
     metadata?: Metadata;
+    version: number;
 }
 export type GenerateDiffStepsResponseBody = {
     documentAri: string;
     generatedSteps: StepJson[];
     latestDocument?: string;
-    userId: string;
     message?: string;
+    userId: string;
 };
 export interface Catchupv2Options {
-    getCurrentPmVersion: () => number;
-    fetchCatchupv2: (fromVersion: number, clientId: number | string | undefined, catchUpOutofSync: boolean, reason?: CatchupEventReason, sessionId?: string) => Promise<Catchupv2Response>;
-    updateMetadata: (metadata: Metadata | undefined) => void;
     analyticsHelper: AnalyticsHelper | undefined;
+    catchUpOutofSync: boolean;
     clientId: number | string | undefined;
+    fetchCatchupv2: (fromVersion: number, clientId: number | string | undefined, catchUpOutofSync: boolean, reason?: CatchupEventReason, sessionId?: string) => Promise<Catchupv2Response>;
+    getCurrentPmVersion: () => number;
+    getState: (() => EditorState) | undefined;
+    onCatchupComplete?: (steps: StepJson[]) => void;
     onStepsAdded: (data: StepsPayload) => void;
-    catchUpOutofSync: boolean;
     reason?: CatchupEventReason;
     sessionId?: string;
-    onCatchupComplete?: (steps: StepJson[]) => void;
-    getState: (() => EditorState) | undefined;
+    updateMetadata: (metadata: Metadata | undefined) => void;
 }
 export type ReconnectionMetadata = {
-    unconfirmedStepsLength: number | undefined;
     disconnectionPeriodSeconds: number | undefined;
+    unconfirmedStepsLength: number | undefined;
 };
 export type ProductInformation = {
     product: string;

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

@@ -117,13 +117,13 @@ export declare class DocumentService implements DocumentServiceInterface {
                 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;
         }[];
@@ -155,9 +155,9 @@ export declare class DocumentService implements DocumentServiceInterface {
      * @example
      */
     setup({ getState, onSyncUpError, clientId, }: {
+        clientId: number | string | undefined;
         getState: () => EditorState;
         onSyncUpError?: SyncUpErrorFunction;
-        clientId: number | string | undefined;
     }): this;
     /**
      * We can use this function to throttle/delay

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

@@ -4,34 +4,34 @@ import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/stat
 import type { InternalError } from '../errors/internal-errors';
 import type { GetResolvedEditorStateReason } from '@atlaskit/editor-common/types';
 export interface DocumentServiceInterface {
-    setup: (params: {
-        getState: () => EditorState;
-        onSyncUpError?: SyncUpErrorFunction;
-        clientId: number | string | undefined;
-    }) => this;
-    updateDocument: (params: {
-        doc: any;
-        version: number;
-        metadata: any;
-        reserveCursor?: boolean;
-    }) => void;
+    getCurrentPmVersion: () => number;
+    getCurrentState: () => Promise<ResolvedEditorState>;
+    getFinalAcknowledgedState: (reason: GetResolvedEditorStateReason) => Promise<ResolvedEditorState>;
+    getIsNamespaceLocked: () => boolean;
+    getUnconfirmedSteps: () => readonly ProseMirrorStep[] | undefined;
+    onErrorHandled: (error: InternalError) => void;
     onRestore: (params: {
         doc: any;
-        version: number;
         metadata: any;
+        version: number;
     }) => void;
+    onStepRejectedError: () => void;
     onStepsAdded: (data: {
-        version: number;
         steps: any[];
+        version: number;
     }) => void;
-    onStepRejectedError: () => void;
     send: (tr: Transaction | null, oldState: EditorState | null, newState: EditorState, sendAnalyticsEvent?: boolean) => void;
     sendStepsFromCurrentState: (sendAnalyticsEvent?: boolean, reason?: GetResolvedEditorStateReason) => void;
+    setup: (params: {
+        clientId: number | string | undefined;
+        getState: () => EditorState;
+        onSyncUpError?: SyncUpErrorFunction;
+    }) => this;
     throttledCatchupv2: () => void;
-    getCurrentState: () => Promise<ResolvedEditorState>;
-    getFinalAcknowledgedState: (reason: GetResolvedEditorStateReason) => Promise<ResolvedEditorState>;
-    getIsNamespaceLocked: () => boolean;
-    getUnconfirmedSteps: () => readonly ProseMirrorStep[] | undefined;
-    getCurrentPmVersion: () => number;
-    onErrorHandled: (error: InternalError) => void;
+    updateDocument: (params: {
+        doc: any;
+        metadata: any;
+        reserveCursor?: boolean;
+        version: number;
+    }) => void;
 }

package/dist/types-ts4.5/errors/internal-errors.d.ts

@@ -13,95 +13,95 @@ export declare enum INTERNAL_ERROR_CODE {
     OUT_OF_SYNC_CLIENT_DATA_LOSS_EVENT = "OUT_OF_SYNC_CLIENT_DATA_LOSS_EVENT"
 }
 type DocumentRecoveryError = {
-    message: string;
     data: {
         code: INTERNAL_ERROR_CODE.DOCUMENT_RESTORE_ERROR;
         status: number;
     };
+    message: string;
 };
 type AddStepsError = {
-    message: string;
     data: {
         code: INTERNAL_ERROR_CODE.ADD_STEPS_ERROR;
         status: number;
     };
+    message: string;
 };
 type OutOfSyncClientDatalossEvent = {
-    message: string;
     data: {
+        code: INTERNAL_ERROR_CODE.OUT_OF_SYNC_CLIENT_DATA_LOSS_EVENT;
         meta: {
             reason?: string;
         };
-        code: INTERNAL_ERROR_CODE.OUT_OF_SYNC_CLIENT_DATA_LOSS_EVENT;
     };
+    message: string;
 };
 export type CatchUpFailedError = {
-    message: string;
     data: {
         code: INTERNAL_ERROR_CODE.CATCHUP_FAILED;
         status: number;
     };
+    message: string;
 };
 export type TokenPermissionError = {
-    message: string;
     data: {
         code: INTERNAL_ERROR_CODE.TOKEN_PERMISSION_ERROR;
-        status: number;
         meta: {
             originalError?: unknown;
             reason?: string;
         };
+        status: number;
     };
+    message: string;
 };
 export type ReconnectionError = {
-    message: string;
     data: {
         code: INTERNAL_ERROR_CODE.RECONNECTION_ERROR;
         status: number;
     };
+    message: string;
 };
 export type ConnectionError = {
-    message: string;
     data: {
         code: INTERNAL_ERROR_CODE.CONNECTION_ERROR;
     };
+    message: string;
 };
 export type ReconnectionNetworkError = {
-    message: string;
     data: {
         code: INTERNAL_ERROR_CODE.RECONNECTION_NETWORK_ISSUE;
     };
+    message: string;
 };
 export type DocumentNotFoundError = {
-    message: string;
     data: {
         code: INTERNAL_ERROR_CODE.DOCUMENT_NOT_FOUND;
         status: number;
     };
+    message: string;
 };
 /**
  * When we try to apply state updates to the editor, if that fails to apply the user can enter an invalid state where no
  * changes can be saved to NCS.
  */
 export type InternalDocumentUpdateFailure = {
-    message: 'The provider failed to apply changes to the editor';
     data: {
         code: INTERNAL_ERROR_CODE.DOCUMENT_UPDATE_ERROR;
         meta: {
-            newVersion?: number;
             editorVersion?: number;
+            newVersion?: number;
         };
         status: 500;
     };
+    message: 'The provider failed to apply changes to the editor';
 };
 /**
  * When in view only mode, we should not generate any steps whatsoever.
  */
 export type ViewOnlyStepsError = {
-    message: 'Attempted to send steps in view only mode';
     data: {
         code: INTERNAL_ERROR_CODE.VIEW_ONLY_STEPS_ERROR;
     };
+    message: 'Attempted to send steps in view only mode';
 };
 /**
  * A union of all possible internal errors, that are mapped to another error if being emitted to the editor.

package/dist/types-ts4.5/errors/ncs-errors.d.ts

@@ -19,7 +19,6 @@ export declare enum NCS_ERROR_CODE {
     PROSEMIRROR_SCHEMA_VALIDATION_ERROR = "PROSEMIRROR_SCHEMA_VALIDATION_ERROR"
 }
 type HeadVersionUpdateFailedError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.HEAD_VERSION_UPDATE_FAILED;
         meta: {
@@ -28,17 +27,17 @@ type HeadVersionUpdateFailedError = {
         };
         status: number;
     };
+    message: string;
 };
 type VersionAlreadyPresentInDynamoError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.VERSION_NUMBER_ALREADY_EXISTS;
         meta: string;
         status: number;
     };
+    message: string;
 };
 type InsufficientEditingPermissionError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.INSUFFICIENT_EDITING_PERMISSION;
         meta: {
@@ -47,65 +46,65 @@ type InsufficientEditingPermissionError = {
         };
         status: number;
     };
+    message: string;
 };
 type ForbiddenUserTokenError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.FORBIDDEN_USER_TOKEN;
         meta: string;
         status: number;
     };
+    message: string;
 };
 type NCSDocumentNotFoundError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.DOCUMENT_NOT_FOUND;
         status: number;
     };
+    message: string;
 };
 type FailedToLoadInitDataError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.INIT_DATA_LOAD_FAILED;
         status: number;
     };
+    message: string;
 };
 /**
  * The backend has retrieved the document successfully, as ADF, but failed to convert it to Prosemirror.
  * This might be because invalid ADF has been written to a document, as it was not validated correctly.
  */
 type ProsemirrorSchemaValidationError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.PROSEMIRROR_SCHEMA_VALIDATION_ERROR;
         status: number;
     };
+    message: string;
 };
 type ErrorMappingError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.ERROR_MAPPING_ERROR;
         status: number;
     };
+    message: string;
 };
 type InvalidNamespaceDefinedError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.NAMESPACE_INVALID;
         meta: string;
         status: number;
     };
+    message: string;
 };
 type SocketNamespaceNotFoundError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.NAMESPACE_NOT_FOUND;
         meta: string;
         status: number;
     };
+    message: string;
 };
 type TenantInstanceMaintenanceError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.TENANT_INSTANCE_MAINTENANCE;
         meta: {
@@ -114,71 +113,72 @@ type TenantInstanceMaintenanceError = {
         };
         status: number;
     };
+    message: string;
 };
 type NamespaceLockedError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.LOCKED_DOCUMENT;
         meta: string;
         status: number;
     };
+    message: string;
 };
 type EmptyBroadcastError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.EMPTY_BROADCAST;
         meta: string;
         status: number;
     };
+    message: string;
 };
 type DynamoError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.DYNAMO_ERROR;
         meta: string;
         status: number;
     };
+    message: string;
 };
 type InvalidActivationIdError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.INVALID_ACTIVATION_ID;
         meta: string;
         status: number;
     };
+    message: string;
 };
 type InvalidDocumentAriError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.INVALID_DOCUMENT_ARI;
         meta: string;
         status: number;
     };
+    message: string;
 };
 type InvalidCloudIdError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.INVALID_CLOUD_ID;
         meta: string;
         status: number;
     };
+    message: string;
 };
 /**
  * The client is trying to send too many messages or messages that are too large. This not expected to be a standard
  * operating condition and should only ever indicate a frontend bug.
  */
 export type RateLimitError = {
-    message: string;
     data: {
         code: NCS_ERROR_CODE.RATE_LIMIT_ERROR;
         meta: {
-            rateLimitType: number;
             maxStepSize: number;
-            stepSizeCounter: number;
+            rateLimitType: number;
             stepCounter: number;
+            stepSizeCounter: number;
         };
         status: 500;
     };
+    message: string;
 };
 export type NCSErrors = HeadVersionUpdateFailedError | VersionAlreadyPresentInDynamoError | InsufficientEditingPermissionError | ForbiddenUserTokenError | NCSDocumentNotFoundError | FailedToLoadInitDataError | ErrorMappingError | InvalidNamespaceDefinedError | SocketNamespaceNotFoundError | TenantInstanceMaintenanceError | NamespaceLockedError | EmptyBroadcastError | DynamoError | InvalidActivationIdError | InvalidDocumentAriError | InvalidCloudIdError | RateLimitError | ProsemirrorSchemaValidationError;
 export {};