@atlaskit/collab-provider 8.7.0 → 8.8.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atlaskit/collab-provider
 
+## 8.8.1
+
+### Patch Changes
+
+- [`c0f3b955ee6`](https://bitbucket.org/atlassian/atlassian-frontend/commits/c0f3b955ee6) - remove the deprecated analytics field 'ttlEnabled'
+
+## 8.8.0
+
+### Minor Changes
+
+- [`56507598609`](https://bitbucket.org/atlassian/atlassian-frontend/commits/56507598609) - Skip minor dependency bump
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 8.7.0
 
 ### Minor Changes

package/dist/cjs/channel.js

@@ -151,8 +151,7 @@ var Channel = /*#__PURE__*/function (_Emitter) {
           // TODO: detect when document init fails and fire corresponding event for it
           _const.EVENT_STATUS.SUCCESS, {
             latency: measure === null || measure === void 0 ? void 0 : measure.duration,
-            resetReason: data === null || data === void 0 ? void 0 : data.resetReason,
-            ttlEnabled: data === null || data === void 0 ? void 0 : data.ttlEnabled
+            resetReason: data === null || data === void 0 ? void 0 : data.resetReason
           });
           var doc = data.doc,
             version = data.version,

package/dist/cjs/version-wrapper.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.version = exports.nextMajorVersion = exports.name = void 0;
 var name = "@atlaskit/collab-provider";
 exports.name = name;
-var version = "8.7.0";
+var version = "8.8.1";
 exports.version = version;
 var nextMajorVersion = function nextMajorVersion() {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');

package/dist/cjs/version.json

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

package/dist/es2019/channel.js

@@ -119,8 +119,7 @@ export class Channel extends Emitter {
           // TODO: detect when document init fails and fire corresponding event for it
           EVENT_STATUS.SUCCESS, {
             latency: measure === null || measure === void 0 ? void 0 : measure.duration,
-            resetReason: data === null || data === void 0 ? void 0 : data.resetReason,
-            ttlEnabled: data === null || data === void 0 ? void 0 : data.ttlEnabled
+            resetReason: data === null || data === void 0 ? void 0 : data.resetReason
           });
           const {
             doc,

package/dist/es2019/version-wrapper.js

@@ -1,5 +1,5 @@
 export const name = "@atlaskit/collab-provider";
-export const version = "8.7.0";
+export const version = "8.8.1";
 export const nextMajorVersion = () => {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/es2019/version.json

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

package/dist/esm/channel.js

@@ -144,8 +144,7 @@ export var Channel = /*#__PURE__*/function (_Emitter) {
           // TODO: detect when document init fails and fire corresponding event for it
           EVENT_STATUS.SUCCESS, {
             latency: measure === null || measure === void 0 ? void 0 : measure.duration,
-            resetReason: data === null || data === void 0 ? void 0 : data.resetReason,
-            ttlEnabled: data === null || data === void 0 ? void 0 : data.ttlEnabled
+            resetReason: data === null || data === void 0 ? void 0 : data.resetReason
           });
           var doc = data.doc,
             version = data.version,

package/dist/esm/version-wrapper.js

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

package/dist/types/feature-flags/types.d.ts

@@ -7,5 +7,5 @@ export interface WithNCSFeatureFlags {
 export declare type RequiredNCSFeatureFlags = Record<keyof Required<NCSFeatureFlags>, boolean>;
 export declare type NCSFeatureFlagsMap = Record<keyof Required<NCSFeatureFlags>, string>;
 export declare const supportedProducts: readonly ["confluence"];
-export declare type SupportedProduct = typeof supportedProducts[number];
+export declare type SupportedProduct = (typeof supportedProducts)[number];
 export declare type ProductKeys = Record<SupportedProduct, NCSFeatureFlagsMap>;

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

@@ -117,7 +117,6 @@ declare type DocumentInitSuccessAnalyticsEvent = {
         eventStatus: EVENT_STATUS.SUCCESS;
         latency?: number;
         resetReason?: string;
-        ttlEnabled?: boolean;
     };
 };
 declare type UpdateParticipantsSuccessAnalyticsEvent = {

package/dist/types-ts4.0/analytics/analytics-helper.d.ts

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

package/dist/types-ts4.0/analytics/performance.d.ts

@@ -0,0 +1,15 @@
+import AnalyticsHelper from './analytics-helper';
+export declare enum MEASURE_NAME {
+    SOCKET_CONNECT = "socketConnect",
+    DOCUMENT_INIT = "documentInit",
+    COMMIT_UNCONFIRMED_STEPS = "commitUnconfirmedSteps",
+    PUBLISH_PAGE = "publishPage",
+    GET_CURRENT_STATE = "getCurrentState"
+}
+export declare const isPerformanceAPIAvailable: () => boolean;
+export declare const measureMap: Map<string, number>;
+export declare function startMeasure(measureName: MEASURE_NAME, analyticsHelper: AnalyticsHelper | undefined): void;
+export declare function stopMeasure(measureName: MEASURE_NAME, analyticsHelper: AnalyticsHelper | undefined, onMeasureComplete?: (duration: number, startTime: number) => void): {
+    duration: number;
+    startTime: number;
+} | undefined;

package/dist/types-ts4.0/analytics/ufo.d.ts

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

package/dist/types-ts4.0/channel.d.ts

@@ -0,0 +1,47 @@
+import { Emitter } from './emitter';
+import type { Config, ChannelEvent, CatchupResponse, Metadata } from './types';
+import type { Socket } from 'socket.io-client';
+import AnalyticsHelper from './analytics/analytics-helper';
+export declare class Channel extends Emitter<ChannelEvent> {
+    private connected;
+    private config;
+    private socket;
+    private reconnectHelper?;
+    private initialized;
+    private analyticsHelper?;
+    private initExperience?;
+    private token?;
+    private network;
+    constructor(config: Config, analyticsHelper: AnalyticsHelper);
+    getInitialized: () => boolean;
+    getConnected: () => boolean;
+    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(shouldInitialize?: boolean): void;
+    private handlePermissionInvalidateToken;
+    private onConnectError;
+    private onReconnectError;
+    private onConnect;
+    private onReceiveData;
+    fetchCatchup: (fromVersion: number) => Promise<CatchupResponse>;
+    /**
+     * Send message to the back-end service over the channel. Timestamp will be added server side.
+     * @throws {NotInitializedError} Channel not initialized
+     * @throws {NotConnectedError} Channel not connected
+     */
+    broadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], "timestamp">, callback?: Function | undefined) => void;
+    /**
+     * Send metadata to the back-end service over the channel
+     * @throws {NotInitializedError} Channel not initialized
+     * @throws {NotConnectedError} Channel not connected
+     */
+    sendMetadata: (metadata: Metadata) => void;
+    sendPresenceJoined(): void;
+    onOnlineHandler: () => void;
+    disconnect(): void;
+}

package/dist/types-ts4.0/config.d.ts

@@ -0,0 +1,5 @@
+export declare const SOCKET_IO_OPTIONS: {
+    RECONNECTION_DELAY_MAX: number;
+    RECONNECTION_DELAY: number;
+    RANDOMIZATION_FACTOR: number;
+};

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

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

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

@@ -0,0 +1,16 @@
+export declare const socketIOReasons: {
+    IO_CLIENT_DISCONNECT: string;
+    IO_SERVER_DISCONNECT: string;
+    TRANSPORT_CLOSED: string;
+    TRANSPORT_ERROR: string;
+    PING_TIMEOUT: string;
+};
+export declare enum DisconnectReason {
+    CLIENT_DISCONNECT = "CLIENT_DISCONNECT",
+    SERVER_DISCONNECT = "SERVER_DISCONNECT",
+    SOCKET_CLOSED = "SOCKET_CLOSED",
+    SOCKET_ERROR = "SOCKET_ERROR",
+    SOCKET_TIMEOUT = "SOCKET_TIMEOUT",
+    UNKNOWN_DISCONNECT = "UNKNOWN_DISCONNECT"
+}
+export declare const disconnectedReasonMapper: (reason: string) => DisconnectReason;

package/dist/types-ts4.0/document/catchup.d.ts

@@ -0,0 +1,9 @@
+import type { CatchupOptions } from '../types';
+import { Mapping, Step } from 'prosemirror-transform';
+/**
+ * Rebase the steps based on the mapping pipeline.
+ * Some steps could be lost, if they are no longer
+ * invalid after rebased.
+ */
+export declare function rebaseSteps(steps: readonly Step[], mapping: Mapping): Step[];
+export declare const catchup: (opt: CatchupOptions) => Promise<void>;

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

@@ -0,0 +1,86 @@
+/// <reference types="lodash" />
+import AnalyticsHelper from '../analytics/analytics-helper';
+import { CatchupResponse, ChannelEvent, CollabEvents, CollabInitPayload, StepsPayload } from '../types';
+import type { Step as ProseMirrorStep } from 'prosemirror-transform';
+import type { MetadataService } from '../metadata/metadata-service';
+import { SyncUpErrorFunction } from '@atlaskit/editor-common/types';
+import type { EditorState, Transaction } from 'prosemirror-state';
+import { ResolvedEditorState } from '@atlaskit/editor-common/collab';
+import { ParticipantsService } from '../participants/participants-service';
+import type { InternalError } from '../errors/error-types';
+export declare class DocumentService {
+    private participantsService;
+    private analyticsHelper;
+    private fetchCatchup;
+    private providerEmitCallback;
+    private broadcast;
+    private getUserId;
+    private onErrorHandled;
+    private metadataService;
+    private getState;
+    private onSyncUpError?;
+    private stepQueue;
+    private stepRejectCounter;
+    private clientId?;
+    /**
+     *
+     * @param participantsService - The participants service, used when users are detected active when making changes to the document
+     * and to emit their telepointers from steps they add
+     * @param analyticsHelper - Helper for analytics events
+     * @param fetchCatchup - Function to fetch "catchup" data, data required to rebase current steps to the latest version.
+     * @param providerEmitCallback - Callback for emitting events to listeners on the provider
+     * @param broadcastMetadata - Callback for broadcasting metadata changes to other clients
+     * @param broadcast - Callback for broadcasting events to other clients
+     * @param getUserId - Callback to fetch the current user's ID
+     * @param onErrorHandled - Callback to handle
+     */
+    constructor(participantsService: ParticipantsService, analyticsHelper: AnalyticsHelper | undefined, fetchCatchup: (fromVersion: number) => Promise<CatchupResponse>, providerEmitCallback: (evt: keyof CollabEvents, data: any) => void, broadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], 'timestamp'>, callback?: Function) => void, getUserId: () => string | undefined, onErrorHandled: (error: InternalError) => void, metadataService: MetadataService);
+    /**
+     * To prevent calling catchup to often, use lodash throttle to reduce the frequency
+     */
+    throttledCatchup: import("lodash").DebouncedFunc<() => Promise<void>>;
+    /**
+     * Called when:
+     *   * session established(offline -> online)
+     *   * try to accept steps but version is behind.
+     */
+    private catchup;
+    getCurrentPmVersion: () => number;
+    private processQueue;
+    getCurrentState: () => Promise<ResolvedEditorState>;
+    private processSteps;
+    getUnconfirmedStepsOrigins: () => readonly Transaction<any>[] | undefined;
+    getUnconfirmedSteps: () => readonly ProseMirrorStep[] | undefined;
+    private applyLocalSteps;
+    /**
+     * Called when we receive steps from the service
+     */
+    onStepsAdded: (data: StepsPayload) => void;
+    onRestore: ({ doc, version, metadata }: CollabInitPayload) => void;
+    getFinalAcknowledgedState: () => Promise<ResolvedEditorState>;
+    updateDocument: ({ doc, version, metadata, reserveCursor, }: CollabInitPayload) => void;
+    /**
+     * Commit the unconfirmed local steps to the back-end service
+     * @throws {Error} Couldn't sync the steps after retrying 30 times
+     */
+    commitUnconfirmedSteps: () => Promise<void>;
+    setup({ getState, onSyncUpError, clientId, }: {
+        getState: () => EditorState;
+        onSyncUpError?: SyncUpErrorFunction;
+        clientId: number | string | undefined;
+    }): this;
+    /**
+     * We can use this function to throttle/delay
+     * Any send steps operation
+     *
+     * The getState function will return the current EditorState
+     * from the EditorView.
+     */
+    sendStepsFromCurrentState(): void;
+    onStepRejectedError: () => void;
+    /**
+     * Send steps from transaction to other participants
+     * It needs the superfluous arguments because we keep the interface of the send API the same as the Synchrony plugin
+     */
+    send(_tr: Transaction | null, _oldState: EditorState | null, newState: EditorState): void;
+}

package/dist/types-ts4.0/document/step-queue-state.d.ts

@@ -0,0 +1,16 @@
+import { StepsPayload } from '../types';
+export declare class StepQueueState {
+    private queuePaused;
+    private queue;
+    queueSteps(data: StepsPayload): void;
+    getQueue: () => StepsPayload[];
+    filterQueue: (condition: (stepsPayload: StepsPayload) => boolean) => void;
+    /**
+     * Get whether the document service has stopped processing new steps whilst it carries out processes such as catchup.
+     * Exposed for testing
+     */
+    isPaused: () => boolean;
+    pauseQueue: () => void;
+    resumeQueue: () => void;
+    shift: () => StepsPayload | undefined;
+}

package/dist/types-ts4.0/emitter.d.ts

@@ -0,0 +1,19 @@
+export declare class Emitter<T = any> {
+    private eventEmitter;
+    /**
+     * Emit events to subscribers
+     */
+    protected emit<K extends keyof T>(evt: K, data: T[K]): this;
+    /**
+     * Subscribe to events emitted by this provider
+     */
+    on<K extends keyof T>(evt: K, handler: (args: T[K]) => void): this;
+    /**
+     * Unsubscribe from events emitted by this provider
+     */
+    off<K extends keyof T>(evt: K, handler: (args: T[K]) => void): this;
+    /**
+     * Unsubscribe from all events emitted by this provider.
+     */
+    unsubscribeAll<K extends keyof T>(evt?: K): this;
+}

package/dist/types-ts4.0/errors/error-code-mapper.d.ts

@@ -0,0 +1,2 @@
+import { InternalError, ProviderError } from './error-types';
+export declare const errorCodeMapper: (error: InternalError) => ProviderError | undefined;