@atlaskit/collab-provider 8.8.2 → 8.9.0

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

@@ -0,0 +1,14 @@
+import { NamespaceStatus } from '../types';
+/**
+ * Allows us to keep track of any namespace changes from the server.
+ * @param isNamespaceLocked - whether the namespace is locked or not, defaults to false
+ */
+export declare class NamespaceService {
+    private isNamespaceLocked;
+    constructor(isNamespaceLocked?: boolean);
+    getIsNamespaceLocked: () => boolean;
+    /**
+     * ESS-2916 namespace status event- lock/unlock
+     */
+    onNamespaceStatusChanged: ({ isLocked, waitTimeInMs, timestamp, }: NamespaceStatus) => Promise<void>;
+}

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

@@ -0,0 +1,12 @@
+import type { CollabParticipant } from '@atlaskit/editor-common/collab';
+import type { PresencePayload } from '../types';
+export declare const PARTICIPANT_UPDATE_INTERVAL: number;
+export type ProviderParticipant = CollabParticipant & {
+    userId: string;
+    clientId: number | string;
+};
+export type ParticipantsMap = Map<string, ProviderParticipant>;
+export type GetUserType = ((userId: string) => Promise<Pick<ProviderParticipant, 'name' | 'avatar' | 'userId'>>) | undefined;
+export declare const createParticipantFromPayload: (payload: PresencePayload & {
+    userId: string;
+}, getUser: GetUserType) => Promise<ProviderParticipant>;

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

@@ -0,0 +1,94 @@
+import type { CollabEventPresenceData, CollabEventDisconnectedData } from '@atlaskit/editor-common/collab';
+import AnalyticsHelper from '../analytics/analytics-helper';
+import type { ChannelEvent, CollabEventTelepointerData, PresencePayload, StepJson, TelepointerPayload } from '../types';
+import { GetUserType } from './participants-helper';
+import { ParticipantsState } from './participants-state';
+/**
+ * This service is responsible for handling presence and participant events, as well as sending them on to the editor or NCS.
+ * @param analyticsHelper Analytics helper instance
+ * @param participantsState Starts with no participants, only add this when testing
+ * @param emit Emit from the Provider class (to the editor)
+ * @param getUser Callback to get user data from the editor
+ * @param channelBroadcast Broadcast from the Channel class (to NCS)
+ * @param sendPresenceJoined Callback to Channel class
+ */
+export declare class ParticipantsService {
+    private analyticsHelper;
+    private participantsState;
+    private emit;
+    private getUser;
+    private channelBroadcast;
+    private sendPresenceJoined;
+    private participantUpdateTimeout;
+    private presenceUpdateTimeout;
+    constructor(analyticsHelper: AnalyticsHelper | undefined, participantsState: ParticipantsState, emit: (evt: 'presence' | 'telepointer' | 'disconnected', data: CollabEventPresenceData | CollabEventTelepointerData | CollabEventDisconnectedData) => void, getUser: GetUserType, channelBroadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], 'timestamp'>, callback?: Function) => void, sendPresenceJoined: () => void);
+    /**
+     * Carries out 3 things: 1) enriches the participant with user data, 2) updates the participantsState, 3) emits the presence event
+     * @param payload Payload from incoming socket event
+     * @returns Awaitable Promise, due to getUser
+     */
+    onParticipantUpdated: (payload: PresencePayload) => Promise<void>;
+    /**
+     * Called when a participant leaves the session.
+     * We emit the `presence` event to update the active avatars in the editor.
+     */
+    onParticipantLeft: ({ sessionId }: PresencePayload) => void;
+    disconnect: (reason: string, sessionId: string | undefined) => void;
+    /**
+     * Updates when users were last active
+     * @param userIds Users in most recent steps
+     */
+    updateLastActive: (userIds?: string[]) => void;
+    /**
+     * Called on receiving steps, emits each step's telepointer
+     * @param steps Steps to extract telepointers from
+     */
+    emitTelepointersFromSteps(steps: StepJson[]): void;
+    /**
+     * Called when we receive a telepointer update from another
+     * participant.
+     */
+    onParticipantTelepointer: (payload: TelepointerPayload, thisSessionId: string | undefined) => void;
+    /**
+     * Every 5 minutes (PARTICIPANT_UPDATE_INTERVAL), removes inactive participants and emits the update to other participants.
+     * Needs to be kicked off in the Provider.
+     * @param sessionId SessionId from provider's connection
+     */
+    startInactiveRemover: (sessionId: string | undefined) => void;
+    /**
+     * Keep list of participants up to date. Filter out inactive users etc.
+     */
+    private filterInactive;
+    /**
+     * Wrapper function to emit with error handling and analytics
+     * @param data Data to emit
+     * @param emit Emit function from Provider
+     */
+    private emitPresence;
+    /**
+     * Wrapper function to emit with error handling and analytics
+     * @param data Data to emit
+     * @param emit Emit function from Provider
+     */
+    private emitTelepointer;
+    /**
+     * Used when the provider is disconnected or destroyed to prevent perpetual timers from continuously running
+     */
+    clearTimers: () => void;
+    private sendPresence;
+    /**
+     * Called when a participant joins the session.
+     *
+     * We keep track of participants internally, 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
+     */
+    onPresenceJoined: (payload: PresencePayload) => void;
+    /**
+     * Called when the current user joins the session.
+     *
+     * This will send both a 'presence' event and a 'participant:updated' event.
+     * This updates both the avatars and the participants list.
+     */
+    onPresence: (payload: PresencePayload) => void;
+}

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

@@ -0,0 +1,13 @@
+import { ParticipantsMap, ProviderParticipant } from './participants-helper';
+export declare class ParticipantsState {
+    private participants;
+    constructor(baseParticipants?: ParticipantsMap);
+    getBySessionId: (sessionId: string) => ProviderParticipant | undefined;
+    setBySessionId: (sessionId: string, participant: ProviderParticipant) => void;
+    getParticipants: () => ProviderParticipant[];
+    removeBySessionId: (sessionId: string) => boolean;
+    clear: () => void;
+    doesntHave: (sessionId: string) => boolean;
+    size: () => number;
+    updateLastActive: (now: number, userIds: string[]) => void;
+}

package/dist/types-ts4.5/participants/telepointers-helper.d.ts

@@ -0,0 +1,4 @@
+import type { AcknowledgementPayload, CollabEventTelepointerData, StepJson } from '../types';
+import { ProviderParticipant } from './participants-helper';
+export declare const telepointerFromStep: (participants: ProviderParticipant[], step: StepJson) => CollabEventTelepointerData | undefined;
+export declare const telepointerCallback: (documentAri: string) => (response: AcknowledgementPayload) => void;

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

@@ -0,0 +1,25 @@
+/// <reference types="lodash" />
+import { ChannelEvent, StepsPayload } from '../types';
+import type { Step as ProseMirrorStep } from 'prosemirror-transform';
+import AnalyticsHelper from '../analytics/analytics-helper';
+import type { InternalError } from '../errors/error-types';
+export declare const commitStep: ({ broadcast, steps, version, userId, clientId, onStepsAdded, onErrorHandled, analyticsHelper, }: {
+    broadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], "timestamp">, callback?: Function) => void;
+    steps: readonly ProseMirrorStep[];
+    version: number;
+    userId: string;
+    clientId: number | string;
+    onStepsAdded: (data: StepsPayload) => void;
+    onErrorHandled: (error: InternalError) => void;
+    analyticsHelper?: AnalyticsHelper | undefined;
+}) => void;
+export declare const throttledCommitStep: import("lodash").DebouncedFunc<({ broadcast, steps, version, userId, clientId, onStepsAdded, onErrorHandled, analyticsHelper, }: {
+    broadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], "timestamp">, callback?: Function) => void;
+    steps: readonly ProseMirrorStep[];
+    version: number;
+    userId: string;
+    clientId: number | string;
+    onStepsAdded: (data: StepsPayload) => void;
+    onErrorHandled: (error: InternalError) => void;
+    analyticsHelper?: AnalyticsHelper | undefined;
+}) => void>;

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

@@ -0,0 +1,146 @@
+import type { EditorState, Transaction } from 'prosemirror-state';
+import type { Step as ProseMirrorStep } from 'prosemirror-transform';
+import { Emitter } from '../emitter';
+import type { ResolvedEditorState } from '@atlaskit/editor-common/collab';
+import type { CollabEditProvider, CollabEvents, CollabEventTelepointerData, Config, Metadata } from '../types';
+import type { SyncUpErrorFunction } from '@atlaskit/editor-common/types';
+export declare const MAX_STEP_REJECTED_ERROR = 15;
+type BaseEvents = Pick<CollabEditProvider<CollabEvents>, 'setup' | 'send' | 'sendMessage'>;
+export declare class Provider extends Emitter<CollabEvents> implements BaseEvents {
+    private channel;
+    private config;
+    private analyticsHelper?;
+    private isChannelInitialized;
+    private initialDraft?;
+    private isProviderInitialized;
+    private isPreinitializing;
+    private sessionId?;
+    private clientId?;
+    private userId?;
+    private presenceUpdateTimeout?;
+    private disconnectedAt?;
+    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;
+    /**
+     * Initialisation logic, called by Jira with a dummy getState function, deprecated in favour of the setup method which allows more configuration
+     * @param {Function} getState Function that returns the editor state, used to retrieve collab-edit properties and to interact with prosemirror-collab
+     * @throws {ProviderInitialisationError} Something went wrong during provider initialisation
+     * @deprecated Use setup method instead
+     */
+    initialize(getState: () => EditorState): this;
+    /**
+     * 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;
+        onSyncUpError?: SyncUpErrorFunction;
+    }): this;
+    private checkForCookies;
+    /**
+     * Send steps from transaction to NCS (and as a consequence to other participants), called from the collab-edit plugin in the editor
+     * @param {Transaction} _tr Deprecated, included to keep API consistent with Synchrony provider
+     * @param {EditorState} _oldState Deprecated, included to keep API consistent with Synchrony provider
+     * @param {EditorState} newState The editor state after applying the transaction
+     * @throws {SendTransactionError} Something went wrong while sending the steps for this transaction
+     */
+    send(_tr: Transaction | null, _oldState: EditorState | null, newState: EditorState): void;
+    /**
+     * @param {InternalError} error The error to handle
+     */
+    private onErrorHandled;
+    /**
+     * Send messages, such as telepointers, to NCS and other participants. Only used for telepointer data (text and node selections) in the editor and JWM. JWM does some weird serialisation stuff on the node selections.
+     * Silently fails if an error occurs, since Presence isn't a critical functionality and self-restores over time.
+     * @param {CollabEventTelepointerData} data Data you want to send to NCS / the other participants
+     * @param {string} data.type Can only be 'telepointer' for now, we don't support anything else yet
+     * @param {CollabSendableSelection} data.selection Object representing the selected element
+     * @param {string} data.sessionId Identifier identifying the session
+     */
+    sendMessage(data: CollabEventTelepointerData): void;
+    private onDisconnected;
+    /**
+     * "Destroy" the provider, disconnect it's connection to the back-end service and unsubscribe all event listeners on the provider.
+     * Used by Jira products (JWM, JPD) to disable the provider
+     * @throws {DestroyError} Something went wrong while shutting down the collab provider
+     */
+    destroy(): this;
+    /**
+     * Disconnect the provider, disconnect it's connection to the back-end service and unsubscribe all event listeners on the provider.
+     * Used by Confluence to disable the provider when a user doesn't have access to a resource.
+     * @deprecated use destroy instead, it does the same thing
+     * @throws {DestroyError} Something went wrong while shutting down the collab provider
+     */
+    disconnect(): this;
+    /**
+     * Disconnect the provider's connection to the back-end service and unsubscribe from all events emitted by this provider. Kept to keep roughly aligned to Synchrony API, which you need to call for each event.
+     * @deprecated use destroy instead, it does the same thing
+     * @throws {DestroyError} Something went wrong while shutting down the collab provider
+     */
+    unsubscribeAll(): this;
+    /**
+     * Update the title of the document in the collab provider and optionally broadcast it to other participants and NCS
+     * @deprecated use setMetadata instead, it does the same thing
+     * @param {string} title Title you want to set on the document
+     * @param {boolean} broadcast (Optional) Flag indicating whether you want to broadcast the title change to the other participants, always true for now (otherwise we would lose title changes)
+     * @throws {SetTitleError} Something went wrong while setting the title
+     */
+    setTitle(title: string, broadcast?: boolean): void;
+    /**
+     * Set editor width, not used any more
+     * @deprecated use setMetadata instead, it does the same thing
+     * @param {string} editorWidth string? indicating the editor width
+     * @param {boolean} broadcast (Optional) Flag indicating whether you want to broadcast the editor width change
+     * @throws {SetEditorWidthError} Something went wrong while setting the editor width
+     */
+    setEditorWidth(editorWidth: string, broadcast?: boolean): void;
+    /**
+     * Set the editor width and title and distribute it to all participants. Used by Confluence
+     * @param {Metadata} metadata The metadata you want to update
+     * @throws {ExampleError} Something went wrong while setting the metadata
+     */
+    setMetadata(metadata: Metadata): void;
+    /**
+     * Returns the documents metadata
+     */
+    getMetadata: () => Metadata;
+    /**
+     * Return the ADF version of the current draft document, together with it's title and the current step version.
+     * Used for draft sync, a process running every 5s for the first editor of a document to sync the document to the Confluence back-end.
+     * @throws {GetCurrentStateError} Something went wrong while returning the current state
+     */
+    getCurrentState: () => Promise<ResolvedEditorState>;
+    /**
+     * Return the final acknowledged (by NCS) ADF version of the current draft document, together with it's title and the current step version.
+     * Used when returning the document to Confluence on publish.
+     * @throws {GetFinalAcknowledgedStateError} Something went wrong while returning the acknowledged state
+     */
+    getFinalAcknowledgedState: () => Promise<ResolvedEditorState>;
+    getUnconfirmedSteps: () => readonly ProseMirrorStep[] | undefined;
+    /**
+     * Used when the provider is disconnected or destroyed to prevent perpetual timers from continuously running
+     */
+    private clearTimers;
+}
+export {};

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

@@ -0,0 +1,5 @@
+import { Provider } from './provider';
+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-ts4.5/types.d.ts

@@ -0,0 +1,265 @@
+import type { Step } from 'prosemirror-transform';
+import type { EditorState, Transaction } from 'prosemirror-state';
+import type { CollabEventConnectionData, CollabEventInitData, CollabEventRemoteData, CollabEventPresenceData, CollabEventConnectingData, ResolvedEditorState } from '@atlaskit/editor-common/collab';
+import type { AnalyticsWebClient } from '@atlaskit/analytics-listeners';
+import type { Manager } from 'socket.io-client';
+import type { DisconnectReason } from './disconnected-reason-mapper';
+import type { InternalError } from './errors/error-types';
+import type { ProviderError } from './errors/error-types';
+import type { SyncUpErrorFunction } from '@atlaskit/editor-common/types';
+import { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import { ProviderParticipant } from './participants/participants-helper';
+export interface Storage {
+    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;
+}
+export interface Config {
+    url: string;
+    documentAri: string;
+    lifecycle?: Lifecycle;
+    storage?: Storage;
+    need404?: boolean;
+    createSocket: (path: string, auth?: AuthCallback | InitAndAuthData, productInfo?: ProductInformation) => Socket;
+    /**
+     * @deprecated: Use promise based getAnalyticsWebClient instead
+     */
+    analyticsClient?: AnalyticsWebClient;
+    getAnalyticsWebClient?: Promise<AnalyticsWebClient>;
+    featureFlags?: {
+        [key: string]: boolean;
+    };
+    getUser?(userId: string): Promise<Pick<ProviderParticipant, 'avatar' | 'name' | 'userId'>>;
+    /**
+     * 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;
+    initialDraft?: InitialDraft;
+}
+export interface InitAndAuthData {
+    initialized: boolean;
+    need404?: boolean;
+    token?: string;
+}
+export type AuthCallback = (cb: (data: InitAndAuthData) => void) => void;
+interface SimpleEventEmitter {
+    on(event: string, fn: Function): SimpleEventEmitter;
+}
+export interface Socket extends SimpleEventEmitter {
+    id: string;
+    connect(): Socket;
+    emit(event: string, ...args: any[]): Socket;
+    close(): Socket;
+    io?: Manager;
+}
+export type LifecycleEvents = 'save' | 'restore';
+export type EventHandler = () => void;
+export interface Lifecycle {
+    on(event: LifecycleEvents, handler: EventHandler): void;
+}
+export type CollabConnectedPayload = CollabEventConnectionData;
+export type CollabConnectingPayload = CollabEventConnectingData;
+export interface CollabDisconnectedPayload {
+    reason: DisconnectReason;
+    sid: string;
+}
+/**
+ * @deprecated Use ProviderError type instead
+ */
+export type CollabErrorPayload = ProviderError;
+export interface CollabInitPayload extends CollabEventInitData {
+    doc: any;
+    version: number;
+    metadata?: Metadata;
+    reserveCursor?: boolean;
+}
+export interface CollabDataPayload extends CollabEventRemoteData {
+    version: number;
+    json: StepJson[];
+    userIds: (number | string)[];
+}
+export type CollabTelepointerPayload = CollabEventTelepointerData;
+export type CollabPresencePayload = CollabEventPresenceData;
+export type CollabMetadataPayload = Metadata;
+export type CollabLocalStepsPayload = {
+    steps: readonly Step[];
+};
+export interface CollabEvents {
+    'metadata:changed': CollabMetadataPayload;
+    init: CollabInitPayload;
+    connected: CollabConnectedPayload;
+    disconnected: CollabDisconnectedPayload;
+    data: CollabDataPayload;
+    telepointer: CollabTelepointerPayload;
+    presence: CollabPresencePayload;
+    'local-steps': CollabLocalStepsPayload;
+    error: CollabErrorPayload;
+    entity: any;
+    connecting: CollabConnectingPayload;
+}
+export interface Metadata {
+    [key: string]: string | number | boolean;
+}
+export type InitPayload = {
+    doc: any;
+    version: number;
+    userId?: string;
+    metadata?: Metadata;
+};
+/**
+ * @description Incoming payload type from the `broadcast` route in NCS
+ * @param {number} timestamp added in NCS
+ * @param {string} sessionId socket.id from NCS
+ * @param data event specific data from NCS
+ */
+export type BroadcastIncomingPayload = {
+    sessionId?: string;
+    timestamp?: number;
+    data: PresencePayload | TelepointerPayload | StepsPayload | any;
+};
+export type PresencePayload = {
+    sessionId: string;
+    userId: string | undefined;
+    clientId: number | string;
+    timestamp: number;
+};
+export type TelepointerPayload = PresencePayload & {
+    selection: CollabSendableSelection;
+};
+type MarkJson = {
+    type: string;
+    attrs: {
+        [key: string]: any;
+    };
+};
+type NodeJson = {
+    type: string;
+    attrs: {
+        [key: string]: any;
+    };
+    content: NodeJson[];
+    marks: MarkJson[];
+    text?: string;
+};
+type SliceJson = {
+    content: NodeJson[];
+    openStart: number;
+    openEnd: number;
+};
+export type StepJson = {
+    stepType?: string;
+    from?: number;
+    to?: number;
+    slice?: SliceJson;
+    clientId: number | string;
+    userId: string;
+    createdAt?: number;
+    structure?: boolean;
+};
+export declare enum AcknowledgementResponseTypes {
+    SUCCESS = "SUCCESS",
+    ERROR = "ERROR"
+}
+export type AcknowledgementSuccessPayload = {
+    type: AcknowledgementResponseTypes.SUCCESS;
+};
+export type AcknowledgementPayload = AcknowledgementSuccessPayload | AcknowledgementErrorPayload;
+export type AddStepAcknowledgementSuccessPayload = {
+    type: AcknowledgementResponseTypes.SUCCESS;
+    version: number;
+};
+export type AcknowledgementErrorPayload = {
+    type: AcknowledgementResponseTypes.ERROR;
+    error: InternalError;
+};
+export type AddStepAcknowledgementPayload = AddStepAcknowledgementSuccessPayload | AcknowledgementErrorPayload;
+export type StepsPayload = {
+    version: number;
+    steps: StepJson[];
+};
+export type NamespaceStatus = {
+    isLocked: boolean;
+    timestamp: number;
+    waitTimeInMs?: number;
+};
+export type ChannelEvent = {
+    connected: {
+        sid: string;
+        initialized: boolean;
+    };
+    init: InitPayload;
+    restore: InitPayload;
+    reconnected: null;
+    'presence:joined': PresencePayload;
+    presence: PresencePayload;
+    'participant:left': PresencePayload;
+    'participant:telepointer': TelepointerPayload;
+    'participant:updated': PresencePayload;
+    'steps:commit': StepsPayload & {
+        userId: string;
+    };
+    'steps:added': StepsPayload;
+    'metadata:changed': Metadata;
+    error: InternalError;
+    disconnect: {
+        reason: string;
+    };
+    status: NamespaceStatus;
+};
+export interface CatchupResponse {
+    doc?: string;
+    version?: number;
+    stepMaps?: any[];
+    metadata?: Metadata;
+}
+export interface CatchupOptions {
+    getCurrentPmVersion: () => number;
+    fetchCatchup: (fromVersion: number) => Promise<CatchupResponse>;
+    filterQueue: (condition: (stepsPayload: StepsPayload) => boolean) => void;
+    getUnconfirmedSteps: () => readonly Step[] | undefined;
+    applyLocalSteps: (steps: Step[]) => void;
+    updateDocument: ({ doc, version, metadata, reserveCursor, }: CollabInitPayload) => void;
+    updateMetadata: (metadata: Metadata | undefined) => void;
+}
+export type ProductInformation = {
+    product: string;
+    subProduct?: string;
+};
+export interface CollabEventTelepointerData {
+    type: 'telepointer';
+    selection: CollabSendableSelection;
+    sessionId: string;
+}
+export interface CollabSendableSelection {
+    type: 'textSelection' | 'nodeSelection';
+    anchor?: number | string;
+    head?: number | string;
+}
+export interface CollabEditProvider<Events extends CollabEvents = CollabEvents> {
+    initialize(getState: () => any, createStep: (json: object) => Step): this;
+    setup(props: {
+        getState?: () => EditorState;
+        onSyncUpError?: SyncUpErrorFunction;
+    }): this;
+    send(tr: Transaction, oldState: EditorState, newState: EditorState): void;
+    on(evt: keyof Events, handler: (...args: any) => void): this;
+    off(evt: keyof Events, handler: (...args: any) => void): this;
+    unsubscribeAll(evt: keyof Events): this;
+    sendMessage<K extends keyof Events>(data: {
+        type: K;
+    } & Events[K]): void;
+    getFinalAcknowledgedState(): Promise<ResolvedEditorState>;
+}
+export {};

package/dist/types-ts4.5/version-wrapper.d.ts

@@ -0,0 +1,3 @@
+export declare const name: string;
+export declare const version: string;
+export declare const nextMajorVersion: () => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/collab-provider",
-  "version": "8.8.2",
+  "version": "8.9.0",
   "description": "A provider for collaborative editing.",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -36,7 +36,7 @@
   "dependencies": {
     "@atlaskit/analytics-gas-types": "^5.1.0",
     "@atlaskit/analytics-listeners": "^8.7.0",
-    "@atlaskit/editor-common": "^74.0.0",
+    "@atlaskit/editor-common": "^74.1.0",
     "@atlaskit/editor-json-transformer": "^8.9.0",
     "@atlaskit/prosemirror-collab": "^0.2.0",
     "@atlaskit/ufo": "^0.2.0",
@@ -68,7 +68,7 @@
     "@atlassian/atlassian-frontend-prettier-config-1.0.1": "npm:@atlassian/atlassian-frontend-prettier-config@1.0.1",
     "@types/prosemirror-model": "^1.11.0",
     "@types/prosemirror-state": "^1.2.0",
-    "prosemirror-model": "1.14.3",
+    "prosemirror-model": "1.16.0",
     "prosemirror-state": "1.3.4",
     "typescript": "~4.9.5"
   },

package/report.api.md

@@ -85,7 +85,7 @@ export interface CollabEditProvider<
   ): void;
   // (undocumented)
   setup(props: {
-    getState: () => EditorState;
+    getState?: () => EditorState;
     onSyncUpError?: SyncUpErrorFunction;
   }): this;
   // (undocumented)
@@ -386,6 +386,8 @@ export class Provider extends Emitter<CollabEvents> implements BaseEvents {
   getFinalAcknowledgedState: () => Promise<ResolvedEditorState>;
   getMetadata: () => Metadata_2;
   // (undocumented)
+  getStatePromiseResolve: (value: PromiseLike<void> | void) => void;
+  // (undocumented)
   getUnconfirmedSteps: () => readonly Step[] | undefined;
   // @deprecated
   initialize(getState: () => EditorState): this;
@@ -404,7 +406,7 @@ export class Provider extends Emitter<CollabEvents> implements BaseEvents {
     getState,
     onSyncUpError,
   }: {
-    getState: () => EditorState;
+    getState?: () => EditorState;
     onSyncUpError?: SyncUpErrorFunction;
   }): this;
   // @deprecated