@anzusystems/common-admin 1.49.0 → 2.0.0-rc.10

package/dist/domains/collab/composables/collabCurrentUserId.js

@@ -0,0 +1,15 @@
+import { ref as e } from "vue";
+// src/domains/collab/composables/collabCurrentUserId.ts
+var t = e(null);
+function n() {
+	function e(e) {
+		t.value = e;
+	}
+	return {
+		setCollabUserCurrentId: e,
+		currentUserId: t
+	};
+}
+export { n as useCollabCurrentUserId };
+
+//# sourceMappingURL=collabCurrentUserId.js.map

package/dist/domains/collab/composables/collabCurrentUserId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collabCurrentUserId.js","names":["currentUserId","ref","useCollabCurrentUserId","setCollabUserCurrentId","value"],"sources":["../../../../src/domains/collab/composables/collabCurrentUserId.ts"],"sourcesContent":["import { ref } from 'vue'\nimport type { IntegerIdNullable } from '@/shared/types/common'\n\nconst currentUserId = ref<IntegerIdNullable>(null)\n\nexport function useCollabCurrentUserId() {\n  function setCollabUserCurrentId(value: IntegerIdNullable) {\n    currentUserId.value = value\n  }\n\n  return {\n    setCollabUserCurrentId,\n    currentUserId,\n  }\n}\n"],"mappings":";;AAGA,IAAMA,IAAgBC,EAAuB,IAAI;AAEjD,SAAgBC,IAAyB;CACvC,SAASC,EAAuB,GAA0B;EACxD,EAAc,QAAQC;CACxB;CAEA,OAAO;EACL;EACA;CACF;AACF"}

package/dist/domains/collab/composables/collabEventBus.d.ts

@@ -0,0 +1,83 @@
+import { EventBusKey } from '@vueuse/core';
+import { CollabFieldDataEnvelope, CollabRoom, CollabRoomPlainData } from '../types/Collab';
+export interface CollabRoomDataChangedEvent {
+    room: CollabRoom;
+    field: string;
+}
+export interface CollabJoinRequestEvent {
+    room: CollabRoom;
+    userId: number;
+    timestamp: number;
+}
+export interface CollabApprovedJoinRequestEvent {
+    room: CollabRoom;
+}
+export interface CollabRejectedJoinRequestEvent {
+    room: CollabRoom;
+}
+export interface CollabStartingEvent {
+    room: CollabRoom;
+    startedCallback: (data: CollabRoomPlainData) => void;
+}
+export interface CollabGatheringBufferDataEvent {
+    room: CollabRoom;
+}
+export interface CollabRequestToTakeModerationEvent {
+    room: CollabRoom;
+    userId: number;
+    timestamp: number;
+}
+export interface CollabApprovedRequestToTakeModerationEvent {
+    room: CollabRoom;
+}
+export interface CollabRejectedRequestToTakeModerationEvent {
+    room: CollabRoom;
+}
+export interface CollabKickedFromRoomEvent {
+    room: CollabRoom;
+}
+export declare const collabRoomDataChangedEventBusKey: EventBusKey<CollabRoomDataChangedEvent>;
+export declare const collabReconnectEventBusKey: EventBusKey<'reconnect'>;
+export declare const collabStartingEventBusKey: EventBusKey<CollabStartingEvent>;
+export declare const collabGatheringBufferDataEventBusKey: EventBusKey<CollabGatheringBufferDataEvent>;
+export declare const collabApprovedJoinRequestEventBusKey: EventBusKey<CollabApprovedJoinRequestEvent>;
+export declare const collabRejectedJoinRequestEventBusKey: EventBusKey<CollabRejectedJoinRequestEvent>;
+export declare const collabJoinRequestEventBusKey: EventBusKey<CollabJoinRequestEvent>;
+export declare const collabApprovedRequestToTakeModerationEventBusKey: EventBusKey<CollabApprovedRequestToTakeModerationEvent>;
+export declare const collabRejectedRequestToTakeModerationEventBusKey: EventBusKey<CollabRejectedRequestToTakeModerationEvent>;
+export declare const collabRequestToTakeModerationEventBusKey: EventBusKey<CollabRequestToTakeModerationEvent>;
+export declare const collabKickedFromRoomEventBusKey: EventBusKey<CollabKickedFromRoomEvent>;
+export declare function useCollabRoomDataChangeEventBus(): import('@vueuse/core').UseEventBusReturn<CollabRoomDataChangedEvent, CollabFieldDataEnvelope>;
+export declare function useCollabReconnectEventBus(): import('@vueuse/core').UseEventBusReturn<"reconnect", any>;
+export declare function useCollabStartingEventBus(): import('@vueuse/core').UseEventBusReturn<CollabStartingEvent, {
+    startedCallback: (data: CollabRoomPlainData) => void;
+}>;
+export declare function useCollabGatheringBufferDataEventBus(): import('@vueuse/core').UseEventBusReturn<CollabGatheringBufferDataEvent, any>;
+export declare function useCollabApprovedJoinRequestEventBus(): import('@vueuse/core').UseEventBusReturn<CollabApprovedJoinRequestEvent, any>;
+export declare function useCollabRejectedJoinRequestEventBus(): import('@vueuse/core').UseEventBusReturn<CollabRejectedJoinRequestEvent, any>;
+export declare function useCollabJoinRequestEventBus(): import('@vueuse/core').UseEventBusReturn<CollabJoinRequestEvent, any>;
+export declare function useCollabApprovedRequestToTakeModerationEventBus(): import('@vueuse/core').UseEventBusReturn<CollabApprovedRequestToTakeModerationEvent, any>;
+export declare function useCollabRejectedRequestToTakeModerationEventBus(): import('@vueuse/core').UseEventBusReturn<CollabRejectedRequestToTakeModerationEvent, any>;
+export declare function useCollabRequestToTakeModerationEventBus(): import('@vueuse/core').UseEventBusReturn<CollabRequestToTakeModerationEvent, any>;
+export declare function useCollabKickedFromRoomEventBus(): import('@vueuse/core').UseEventBusReturn<CollabKickedFromRoomEvent, any>;
+export declare const CollabFieldLockType: {
+    readonly Acquire: "acquire";
+    readonly Release: "release";
+};
+export type CollabFieldLockTypeType = (typeof CollabFieldLockType)[keyof typeof CollabFieldLockType];
+export declare const CollabFieldLockStatus: {
+    readonly Success: "success";
+    readonly Failure: "failure";
+};
+export type CollabFieldLockStatusType = (typeof CollabFieldLockStatus)[keyof typeof CollabFieldLockStatus];
+export interface CollabFieldLockStatusPayload {
+    type: CollabFieldLockTypeType;
+    status: CollabFieldLockStatusType;
+}
+export declare const createFieldLockStatusPayload: (type: CollabFieldLockTypeType, status: CollabFieldLockStatusType) => CollabFieldLockStatusPayload;
+export interface CollabFieldLockStatusEvent {
+    room: CollabRoom;
+    field: string;
+}
+export declare const collabFieldLockStatusEventBusKey: EventBusKey<CollabFieldLockStatusEvent>;
+export declare function useCollabFieldLockStatusEventBus(): import('@vueuse/core').UseEventBusReturn<CollabFieldLockStatusEvent, CollabFieldLockStatusPayload>;

package/dist/domains/collab/composables/collabEventBus.js

@@ -0,0 +1,52 @@
+import { useEventBus as e } from "@vueuse/core";
+// src/domains/collab/composables/collabEventBus.ts
+var t = Symbol("anzu:collabRoomDataChanged"), n = Symbol("anzu:collabReconnect"), r = Symbol("anzu:collabStarting"), i = Symbol("anzu:collabGatheringBufferData"), a = Symbol("anzu:collabApprovedJoinRequest"), o = Symbol("anzu:collabRejectedJoinRequest"), s = Symbol("anzu:collabJoinRequest"), c = Symbol("anzu:collabApprovedRequestToTakeModeration"), l = Symbol("anzu:collabRejectedRequestToTakeModeration"), u = Symbol("anzu:collabRequestToTakeModeration"), d = Symbol("anzu:collabKickedFromRoom");
+function f() {
+	return e(t);
+}
+function p() {
+	return e(n);
+}
+function m() {
+	return e(r);
+}
+function h() {
+	return e(i);
+}
+function g() {
+	return e(a);
+}
+function _() {
+	return e(o);
+}
+function v() {
+	return e(s);
+}
+function y() {
+	return e(c);
+}
+function b() {
+	return e(l);
+}
+function x() {
+	return e(u);
+}
+function S() {
+	return e(d);
+}
+var C = {
+	Acquire: "acquire",
+	Release: "release"
+}, w = {
+	Success: "success",
+	Failure: "failure"
+}, T = (e, t) => ({
+	type: e,
+	status: t
+}), E = Symbol("anzu:collabFieldLockStatus");
+function D() {
+	return e(E);
+}
+export { w as CollabFieldLockStatus, C as CollabFieldLockType, a as collabApprovedJoinRequestEventBusKey, c as collabApprovedRequestToTakeModerationEventBusKey, E as collabFieldLockStatusEventBusKey, i as collabGatheringBufferDataEventBusKey, s as collabJoinRequestEventBusKey, d as collabKickedFromRoomEventBusKey, n as collabReconnectEventBusKey, o as collabRejectedJoinRequestEventBusKey, l as collabRejectedRequestToTakeModerationEventBusKey, u as collabRequestToTakeModerationEventBusKey, t as collabRoomDataChangedEventBusKey, r as collabStartingEventBusKey, T as createFieldLockStatusPayload, g as useCollabApprovedJoinRequestEventBus, y as useCollabApprovedRequestToTakeModerationEventBus, D as useCollabFieldLockStatusEventBus, h as useCollabGatheringBufferDataEventBus, v as useCollabJoinRequestEventBus, S as useCollabKickedFromRoomEventBus, p as useCollabReconnectEventBus, _ as useCollabRejectedJoinRequestEventBus, b as useCollabRejectedRequestToTakeModerationEventBus, x as useCollabRequestToTakeModerationEventBus, f as useCollabRoomDataChangeEventBus, m as useCollabStartingEventBus };
+
+//# sourceMappingURL=collabEventBus.js.map

package/dist/domains/collab/composables/collabEventBus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collabEventBus.js","names":["collabRoomDataChangedEventBusKey","collabReconnectEventBusKey","collabStartingEventBusKey","collabGatheringBufferDataEventBusKey","collabApprovedJoinRequestEventBusKey","collabRejectedJoinRequestEventBusKey","collabJoinRequestEventBusKey","collabApprovedRequestToTakeModerationEventBusKey","collabRejectedRequestToTakeModerationEventBusKey","collabRequestToTakeModerationEventBusKey","collabKickedFromRoomEventBusKey","useCollabRoomDataChangeEventBus","useEventBus","useCollabReconnectEventBus","useCollabStartingEventBus","useCollabGatheringBufferDataEventBus","useCollabApprovedJoinRequestEventBus","useCollabRejectedJoinRequestEventBus","useCollabJoinRequestEventBus","useCollabApprovedRequestToTakeModerationEventBus","useCollabRejectedRequestToTakeModerationEventBus","useCollabRequestToTakeModerationEventBus","useCollabKickedFromRoomEventBus","CollabFieldLockType","CollabFieldLockStatus","createFieldLockStatusPayload","collabFieldLockStatusEventBusKey","useCollabFieldLockStatusEventBus"],"sources":["../../../../src/domains/collab/composables/collabEventBus.ts"],"sourcesContent":["import type { EventBusKey } from '@vueuse/core'\nimport { useEventBus } from '@vueuse/core'\nimport type { CollabFieldDataEnvelope, CollabRoom, CollabRoomPlainData } from '@/domains/collab/types/Collab'\n\nexport interface CollabRoomDataChangedEvent {\n  room: CollabRoom\n  field: string\n}\n\nexport interface CollabJoinRequestEvent {\n  room: CollabRoom\n  userId: number\n  timestamp: number\n}\n\nexport interface CollabApprovedJoinRequestEvent {\n  room: CollabRoom\n}\n\nexport interface CollabRejectedJoinRequestEvent {\n  room: CollabRoom\n}\n\nexport interface CollabStartingEvent {\n  room: CollabRoom\n  startedCallback: (data: CollabRoomPlainData) => void\n}\n\nexport interface CollabGatheringBufferDataEvent {\n  room: CollabRoom\n}\n\nexport interface CollabRequestToTakeModerationEvent {\n  room: CollabRoom\n  userId: number\n  timestamp: number\n}\n\nexport interface CollabApprovedRequestToTakeModerationEvent {\n  room: CollabRoom\n}\n\nexport interface CollabRejectedRequestToTakeModerationEvent {\n  room: CollabRoom\n}\n\nexport interface CollabKickedFromRoomEvent {\n  room: CollabRoom\n}\n\nexport const collabRoomDataChangedEventBusKey: EventBusKey<CollabRoomDataChangedEvent> =\n  Symbol('anzu:collabRoomDataChanged')\n\nexport const collabReconnectEventBusKey: EventBusKey<'reconnect'> = Symbol('anzu:collabReconnect')\n\nexport const collabStartingEventBusKey: EventBusKey<CollabStartingEvent> = Symbol('anzu:collabStarting')\n\nexport const collabGatheringBufferDataEventBusKey: EventBusKey<CollabGatheringBufferDataEvent> = Symbol(\n  'anzu:collabGatheringBufferData'\n)\n\nexport const collabApprovedJoinRequestEventBusKey: EventBusKey<CollabApprovedJoinRequestEvent> = Symbol(\n  'anzu:collabApprovedJoinRequest'\n)\n\nexport const collabRejectedJoinRequestEventBusKey: EventBusKey<CollabRejectedJoinRequestEvent> = Symbol(\n  'anzu:collabRejectedJoinRequest'\n)\n\nexport const collabJoinRequestEventBusKey: EventBusKey<CollabJoinRequestEvent> = Symbol('anzu:collabJoinRequest')\n\nexport const collabApprovedRequestToTakeModerationEventBusKey: EventBusKey<CollabApprovedRequestToTakeModerationEvent> =\n  Symbol('anzu:collabApprovedRequestToTakeModeration')\n\nexport const collabRejectedRequestToTakeModerationEventBusKey: EventBusKey<CollabRejectedRequestToTakeModerationEvent> =\n  Symbol('anzu:collabRejectedRequestToTakeModeration')\n\nexport const collabRequestToTakeModerationEventBusKey: EventBusKey<CollabRequestToTakeModerationEvent> = Symbol(\n  'anzu:collabRequestToTakeModeration'\n)\n\nexport const collabKickedFromRoomEventBusKey: EventBusKey<CollabKickedFromRoomEvent> =\n  Symbol('anzu:collabKickedFromRoom')\n\nexport function useCollabRoomDataChangeEventBus() {\n  return useEventBus<CollabRoomDataChangedEvent, CollabFieldDataEnvelope>(collabRoomDataChangedEventBusKey)\n}\n\nexport function useCollabReconnectEventBus() {\n  return useEventBus(collabReconnectEventBusKey)\n}\n\nexport function useCollabStartingEventBus() {\n  return useEventBus<CollabStartingEvent, { startedCallback: (data: CollabRoomPlainData) => void }>(\n    collabStartingEventBusKey\n  )\n}\n\nexport function useCollabGatheringBufferDataEventBus() {\n  return useEventBus<CollabGatheringBufferDataEvent>(collabGatheringBufferDataEventBusKey)\n}\n\nexport function useCollabApprovedJoinRequestEventBus() {\n  return useEventBus<CollabApprovedJoinRequestEvent>(collabApprovedJoinRequestEventBusKey)\n}\n\nexport function useCollabRejectedJoinRequestEventBus() {\n  return useEventBus<CollabRejectedJoinRequestEvent>(collabRejectedJoinRequestEventBusKey)\n}\n\nexport function useCollabJoinRequestEventBus() {\n  return useEventBus<CollabJoinRequestEvent>(collabJoinRequestEventBusKey)\n}\n\nexport function useCollabApprovedRequestToTakeModerationEventBus() {\n  return useEventBus<CollabApprovedRequestToTakeModerationEvent>(collabApprovedRequestToTakeModerationEventBusKey)\n}\n\nexport function useCollabRejectedRequestToTakeModerationEventBus() {\n  return useEventBus<CollabRejectedRequestToTakeModerationEvent>(collabRejectedRequestToTakeModerationEventBusKey)\n}\n\nexport function useCollabRequestToTakeModerationEventBus() {\n  return useEventBus<CollabRequestToTakeModerationEvent>(collabRequestToTakeModerationEventBusKey)\n}\n\nexport function useCollabKickedFromRoomEventBus() {\n  return useEventBus<CollabKickedFromRoomEvent>(collabKickedFromRoomEventBusKey)\n}\n\nexport const CollabFieldLockType = {\n  Acquire: 'acquire',\n  Release: 'release',\n} as const\nexport type CollabFieldLockTypeType = (typeof CollabFieldLockType)[keyof typeof CollabFieldLockType]\n\nexport const CollabFieldLockStatus = {\n  Success: 'success',\n  Failure: 'failure',\n} as const\nexport type CollabFieldLockStatusType = (typeof CollabFieldLockStatus)[keyof typeof CollabFieldLockStatus]\n\nexport interface CollabFieldLockStatusPayload {\n  type: CollabFieldLockTypeType\n  status: CollabFieldLockStatusType\n}\n\nexport const createFieldLockStatusPayload = (\n  type: CollabFieldLockTypeType,\n  status: CollabFieldLockStatusType\n): CollabFieldLockStatusPayload => ({\n  type,\n  status,\n})\n\nexport interface CollabFieldLockStatusEvent {\n  room: CollabRoom\n  field: string\n}\n\nexport const collabFieldLockStatusEventBusKey: EventBusKey<CollabFieldLockStatusEvent> =\n  Symbol('anzu:collabFieldLockStatus')\n\nexport function useCollabFieldLockStatusEventBus() {\n  return useEventBus<CollabFieldLockStatusEvent, CollabFieldLockStatusPayload>(collabFieldLockStatusEventBusKey)\n}\n"],"mappings":";;AAkDA,IAAaA,IACX,OAAO,4BAA4B,GAExBC,IAAuD,OAAO,sBAAsB,GAEpFC,IAA8D,OAAO,qBAAqB,GAE1FC,IAAoF,OAC/F,gCACF,GAEaC,IAAoF,OAC/F,gCACF,GAEaC,IAAoF,OAC/F,gCACF,GAEaC,IAAoE,OAAO,wBAAwB,GAEnGC,IACX,OAAO,4CAA4C,GAExCC,IACX,OAAO,4CAA4C,GAExCC,IAA4F,OACvG,oCACF,GAEaC,IACX,OAAO,2BAA2B;AAEpC,SAAgBC,IAAkC;CAChD,OAAOC,EAAiEZ,CAAgC;AAC1G;AAEA,SAAgBa,IAA6B;CAC3C,OAAOD,EAAYX,CAA0B;AAC/C;AAEA,SAAgBa,IAA4B;CAC1C,OAAOF,EACLV,CACF;AACF;AAEA,SAAgBa,IAAuC;CACrD,OAAOH,EAA4CT,CAAoC;AACzF;AAEA,SAAgBa,IAAuC;CACrD,OAAOJ,EAA4CR,CAAoC;AACzF;AAEA,SAAgBa,IAAuC;CACrD,OAAOL,EAA4CP,CAAoC;AACzF;AAEA,SAAgBa,IAA+B;CAC7C,OAAON,EAAoCN,CAA4B;AACzE;AAEA,SAAgBa,IAAmD;CACjE,OAAOP,EAAwDL,CAAgD;AACjH;AAEA,SAAgBa,IAAmD;CACjE,OAAOR,EAAwDJ,CAAgD;AACjH;AAEA,SAAgBa,IAA2C;CACzD,OAAOT,EAAgDH,CAAwC;AACjG;AAEA,SAAgBa,IAAkC;CAChD,OAAOV,EAAuCF,CAA+B;AAC/E;AAEA,IAAaa,IAAsB;CACjC,SAAS;CACT,SAAS;AACX,GAGaC,IAAwB;CACnC,SAAS;CACT,SAAS;AACX,GAQaC,KACX,GACA,OACkC;CAClC;CACA;AACF,IAOaC,IACX,OAAO,4BAA4B;AAErC,SAAgBC,IAAmC;CACjD,OAAOf,EAAsEc,CAAgC;AAC/G"}

package/dist/domains/collab/composables/collabField.d.ts

@@ -0,0 +1,23 @@
+import { CollabFieldData, CollabFieldDataEnvelope, CollabFieldLockOptions, CollabFieldName, CollabRoom } from '../types/Collab';
+import { CollabFieldLockStatusPayload } from './collabEventBus';
+import { Fn } from '@vueuse/core';
+/**
+ * `reacquireWhenActive`: a lock the component requested and has
+ * not released is requested again whenever the room turns active.
+ * This covers a reconnect, where the server released it, and
+ * another editor joining while this one was alone and held none.
+ * For a field that holds the lock while focused.
+ */
+export declare function useCollabField(room: CollabRoom, field: CollabFieldName, disableAutoUnsubscribe?: boolean, reacquireWhenActive?: boolean): {
+    addCollabFieldDataChangeListener: (callback: (data: CollabFieldDataEnvelope) => void) => void;
+    addCollabFieldLockStatusListener: (callback: (data: CollabFieldLockStatusPayload) => void) => void;
+    addCollabGatheringBufferDataListener: (callback: () => void) => void;
+    acquireCollabFieldLock: (options?: Partial<CollabFieldLockOptions>) => void;
+    releaseCollabFieldLock: (data: CollabFieldData, options?: Partial<CollabFieldLockOptions>) => void;
+    changeCollabFieldData: (data: CollabFieldData) => void;
+    lockedByUser: import('vue').ComputedRef<number | null>;
+    collabFieldDataBufferState: import('vue').Reactive<Map<string, Map<string, unknown>>>;
+    unsubscribeCollabFieldDataChangeListener: import('vue').Ref<Fn | undefined, Fn | undefined>;
+    unsubscribeCollabFieldLockStatusListener: import('vue').Ref<Fn | undefined, Fn | undefined>;
+    unsubscribeCollabGatheringBufferData: import('vue').Ref<Fn | undefined, Fn | undefined>;
+};

package/dist/domains/collab/composables/collabField.js

@@ -0,0 +1,89 @@
+import { CollabStatus as e, isCollabFailedChangeRoomLockCallback as t, isCollabSuccessChangeRoomLockCallback as n } from "../types/Collab.js";
+import { CollabFieldLockStatus as r, CollabFieldLockType as i, createFieldLockStatusPayload as a, useCollabFieldLockStatusEventBus as o, useCollabGatheringBufferDataEventBus as s, useCollabRoomDataChangeEventBus as c } from "./collabEventBus.js";
+import { useCollabStateInternal as l } from "./collabState.js";
+import { isDefined as u, isUndefined as d } from "../../../shared/utils/common.js";
+import { useCommonAdminCollabOptions as f } from "./commonAdminCollabOptions.js";
+import { useCollabCurrentUserId as p } from "./collabCurrentUserId.js";
+import { computed as m, ref as h, watch as g } from "vue";
+import { tryOnBeforeUnmount as _ } from "@vueuse/core";
+// src/domains/collab/composables/collabField.ts
+function v(v, y, b = !1, x = !1) {
+	let { collabOptions: S } = f(), { currentUserId: C } = p(), { collabSocket: w, collabFieldLocksState: T, collabFieldDataBufferState: E, collabRoomInfoState: D, setFieldLockUnanswered: O, fieldLockMaybeHeld: k } = l(), A = c(), j = h(), M = h(), N = o(), P = h(), F = h(), I = s(), L = h(), R = h(), z = (e, t) => {
+		e.room !== v || e.field !== y || d(t) || d(M.value) || M.value(t);
+	}, B = (e, t) => {
+		e.room !== v || e.field !== y || d(t) || d(F.value) || F.value(t);
+	}, V = (e) => {
+		e.room === v && u(R.value) && R.value();
+	}, H = (e) => {
+		M.value = e, j.value = A.on(z);
+	}, U = (e) => {
+		F.value = e, P.value = N.on(B);
+	}, W = (e) => {
+		R.value = e, L.value = I.on(V);
+	};
+	_(() => {
+		b || (u(j.value) && j.value(), u(P.value) && P.value(), u(L.value) && L.value());
+	});
+	let G = m(() => {
+		let e = T.get(v);
+		if (e) {
+			let t = e.get(y);
+			if (t && C.value !== t) return t;
+		}
+		return null;
+	}), K = null, q = (o = {}) => {
+		if (!S.value.enabled || d(w.value)) return;
+		K = o;
+		let s = D.get(v);
+		s && s.status === e.Inactive || w.value?.timeout(1e3).emit("acquireFieldLock", v, y, o, (e, o) => {
+			let s = {
+				field: y,
+				room: v
+			};
+			if (e && O(v, y, !0), e || t(o)) N.emit(s, a(i.Acquire, r.Failure));
+			else if (n(o)) {
+				T.has(v) || T.set(v, /* @__PURE__ */ new Map());
+				let e = new Map(o.locks ? Object.entries(o.locks) : []);
+				for (let [t, n] of e.entries()) T.get(v)?.set(t, n);
+				N.emit(s, a(i.Acquire, r.Success));
+			}
+		});
+	};
+	return x && g(() => D.get(v)?.status, (t, n) => {
+		t === e.Active && n !== e.Active && K !== null && q(K);
+	}), {
+		addCollabFieldDataChangeListener: H,
+		addCollabFieldLockStatusListener: U,
+		addCollabGatheringBufferDataListener: W,
+		acquireCollabFieldLock: q,
+		releaseCollabFieldLock: (o, s = {}) => {
+			if (!S.value.enabled || d(w.value)) return;
+			K = null;
+			let c = D.get(v);
+			c && c.status === e.Inactive && (E.has(v) || E.set(v, /* @__PURE__ */ new Map()), E.get(v)?.set(y, o), !w.value.connected || !k(v, y, C.value)) || w.value?.timeout(1e3).emit("releaseFieldLock", v, y, o, s, (e, o) => {
+				let s = {
+					field: y,
+					room: v
+				};
+				if (e || t(o)) N.emit(s, a(i.Release, r.Failure));
+				else if (n(o)) {
+					if (O(v, y, !1), T.has(v) || T.set(v, /* @__PURE__ */ new Map()), o.locks) for (let e of Object.keys(o.locks)) T.get(v)?.delete(e);
+					N.emit(s, a(i.Release, r.Success));
+				}
+			});
+		},
+		changeCollabFieldData: (t) => {
+			if (!S.value.enabled || d(w.value)) return;
+			let n = D.get(v);
+			n && n.status === e.Inactive || w.value.emit("changeFieldData", v, y, t, () => {});
+		},
+		lockedByUser: G,
+		collabFieldDataBufferState: E,
+		unsubscribeCollabFieldDataChangeListener: j,
+		unsubscribeCollabFieldLockStatusListener: P,
+		unsubscribeCollabGatheringBufferData: L
+	};
+}
+export { v as useCollabField };
+
+//# sourceMappingURL=collabField.js.map

package/dist/domains/collab/composables/collabField.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collabField.js","names":["useCollabField","useCommonAdminCollabOptions","useCollabCurrentUserId","useCollabStateInternal","changeEventBus","useCollabRoomDataChangeEventBus","unsubscribeCollabFieldDataChangeListener","ref","fieldChangeCallback","fieldLockStatusEventBus","useCollabFieldLockStatusEventBus","unsubscribeCollabFieldLockStatusListener","fieldLockStatusCallback","collabGatheringBufferDataEventBus","useCollabGatheringBufferDataEventBus","unsubscribeCollabGatheringBufferData","collabGatheringBufferDataCallback","fieldChangeEventBusListener","event","room","field","isUndefined","payload","fieldLockStatusEventBusListener","collabGatheringBufferDataEventBusListener","isDefined","addCollabFieldDataChangeListener","callback","addCollabFieldLockStatusListener","addCollabGatheringBufferDataListener","disableAutoUnsubscribe","lockedByUser","computed","roomLockData","collabFieldLocksState","lock","currentUserId","lockWanted","acquireCollabFieldLock","collabOptions","collabSocket","options","roomInfo","collabRoomInfoState","CollabStatus","statusEvent","error","setFieldLockUnanswered","isCollabFailedChangeRoomLockCallback","response","createFieldLockStatusPayload","CollabFieldLockType","CollabFieldLockStatus","isCollabSuccessChangeRoomLockCallback","locks","reacquireWhenActive","watch","status","previous","collabFieldDataBufferState","data","fieldLockMaybeHeld"],"sources":["../../../../src/domains/collab/composables/collabField.ts"],"sourcesContent":["import {\n  type CollabChangeRoomLockCallbackTypes,\n  type CollabFieldData,\n  type CollabFieldDataEnvelope,\n  type CollabFieldLockOptions,\n  type CollabFieldName,\n  type CollabRoom,\n  CollabStatus,\n  isCollabFailedChangeRoomLockCallback,\n  isCollabSuccessChangeRoomLockCallback,\n} from '@/domains/collab/types/Collab'\nimport { computed, ref, watch } from 'vue'\nimport {\n  CollabFieldLockStatus,\n  type CollabFieldLockStatusEvent,\n  type CollabFieldLockStatusPayload,\n  CollabFieldLockType,\n  type CollabGatheringBufferDataEvent,\n  type CollabRoomDataChangedEvent,\n  createFieldLockStatusPayload,\n  useCollabFieldLockStatusEventBus,\n  useCollabGatheringBufferDataEventBus,\n  useCollabRoomDataChangeEventBus,\n} from '@/domains/collab/composables/collabEventBus'\nimport { type Fn, tryOnBeforeUnmount } from '@vueuse/core'\nimport { useCollabStateInternal } from '@/domains/collab/composables/collabState'\nimport { isDefined, isUndefined } from '@/shared/utils/common'\nimport { useCommonAdminCollabOptions } from '@/domains/collab/composables/commonAdminCollabOptions'\nimport { useCollabCurrentUserId } from '@/domains/collab/composables/collabCurrentUserId'\n\n/**\n * `reacquireWhenActive`: a lock the component requested and has\n * not released is requested again whenever the room turns active.\n * This covers a reconnect, where the server released it, and\n * another editor joining while this one was alone and held none.\n * For a field that holds the lock while focused.\n */\nexport function useCollabField(\n  room: CollabRoom,\n  field: CollabFieldName,\n  disableAutoUnsubscribe = false,\n  reacquireWhenActive = false\n) {\n  const { collabOptions } = useCommonAdminCollabOptions()\n  const { currentUserId } = useCollabCurrentUserId()\n  const {\n    collabSocket,\n    collabFieldLocksState,\n    collabFieldDataBufferState,\n    collabRoomInfoState,\n    setFieldLockUnanswered,\n    fieldLockMaybeHeld,\n  } = useCollabStateInternal()\n\n  const changeEventBus = useCollabRoomDataChangeEventBus()\n  const unsubscribeCollabFieldDataChangeListener = ref<undefined | Fn>()\n  const fieldChangeCallback = ref<undefined | ((payload: CollabFieldDataEnvelope) => void)>()\n\n  const fieldLockStatusEventBus = useCollabFieldLockStatusEventBus()\n  const unsubscribeCollabFieldLockStatusListener = ref<undefined | Fn>()\n  const fieldLockStatusCallback = ref<undefined | ((payload: CollabFieldLockStatusPayload) => void)>()\n\n  const collabGatheringBufferDataEventBus = useCollabGatheringBufferDataEventBus()\n  const unsubscribeCollabGatheringBufferData = ref<undefined | Fn>()\n  const collabGatheringBufferDataCallback = ref<undefined | Fn>()\n\n  const fieldChangeEventBusListener = (event: CollabRoomDataChangedEvent, payload?: CollabFieldDataEnvelope) => {\n    if (\n      event.room !== room ||\n      event.field !== field ||\n      isUndefined(payload) ||\n      isUndefined(fieldChangeCallback.value)\n    ) {\n      return\n    }\n    fieldChangeCallback.value(payload)\n  }\n\n  const fieldLockStatusEventBusListener = (\n    event: CollabFieldLockStatusEvent,\n    payload?: CollabFieldLockStatusPayload\n  ) => {\n    if (\n      event.room !== room ||\n      event.field !== field ||\n      isUndefined(payload) ||\n      isUndefined(fieldLockStatusCallback.value)\n    ) {\n      return\n    }\n    fieldLockStatusCallback.value(payload)\n  }\n\n  const collabGatheringBufferDataEventBusListener = (event: CollabGatheringBufferDataEvent) => {\n    if (event.room === room && isDefined(collabGatheringBufferDataCallback.value)) {\n      collabGatheringBufferDataCallback.value()\n    }\n  }\n\n  const addCollabFieldDataChangeListener = (callback: (data: CollabFieldDataEnvelope) => void) => {\n    fieldChangeCallback.value = callback\n    unsubscribeCollabFieldDataChangeListener.value = changeEventBus.on(fieldChangeEventBusListener)\n  }\n  const addCollabFieldLockStatusListener = (callback: (data: CollabFieldLockStatusPayload) => void) => {\n    fieldLockStatusCallback.value = callback\n    unsubscribeCollabFieldLockStatusListener.value = fieldLockStatusEventBus.on(fieldLockStatusEventBusListener)\n  }\n\n  const addCollabGatheringBufferDataListener = (callback: () => void) => {\n    collabGatheringBufferDataCallback.value = callback\n    unsubscribeCollabGatheringBufferData.value = collabGatheringBufferDataEventBus.on(\n      collabGatheringBufferDataEventBusListener\n    )\n  }\n\n  tryOnBeforeUnmount(() => {\n    if (disableAutoUnsubscribe) return\n    if (isDefined(unsubscribeCollabFieldDataChangeListener.value)) {\n      unsubscribeCollabFieldDataChangeListener.value()\n    }\n    if (isDefined(unsubscribeCollabFieldLockStatusListener.value)) {\n      unsubscribeCollabFieldLockStatusListener.value()\n    }\n    if (isDefined(unsubscribeCollabGatheringBufferData.value)) {\n      unsubscribeCollabGatheringBufferData.value()\n    }\n  })\n\n  const lockedByUser = computed(() => {\n    const roomLockData = collabFieldLocksState.get(room)\n    if (roomLockData) {\n      const lock = roomLockData.get(field)\n      if (lock && currentUserId.value !== lock) {\n        return lock\n      }\n    }\n    return null\n  })\n\n  let lockWanted: Partial<CollabFieldLockOptions> | null = null\n  const acquireCollabFieldLock = (options: Partial<CollabFieldLockOptions> = {}) => {\n    if (!collabOptions.value.enabled || isUndefined(collabSocket.value)) return\n    lockWanted = options\n    const roomInfo = collabRoomInfoState.get(room)\n    if (roomInfo && roomInfo.status === CollabStatus.Inactive) return\n    collabSocket.value\n      ?.timeout(1000)\n      .emit('acquireFieldLock', room, field, options, (error, response: CollabChangeRoomLockCallbackTypes) => {\n        const statusEvent: CollabFieldLockStatusEvent = { field, room }\n        if (error) setFieldLockUnanswered(room, field, true)\n        if (error || isCollabFailedChangeRoomLockCallback(response)) {\n          return void fieldLockStatusEventBus.emit(\n            statusEvent,\n            createFieldLockStatusPayload(CollabFieldLockType.Acquire, CollabFieldLockStatus.Failure)\n          )\n        }\n        if (isCollabSuccessChangeRoomLockCallback(response)) {\n          if (!collabFieldLocksState.has(room)) {\n            collabFieldLocksState.set(room, new Map())\n          }\n          const locks = new Map(response.locks ? Object.entries(response.locks) : [])\n          for (const [field, lock] of locks.entries()) {\n            collabFieldLocksState.get(room)?.set(field, lock)\n          }\n\n          return void fieldLockStatusEventBus.emit(\n            statusEvent,\n            createFieldLockStatusPayload(CollabFieldLockType.Acquire, CollabFieldLockStatus.Success)\n          )\n        }\n      })\n  }\n\n  const releaseCollabFieldLock = (data: CollabFieldData, options: Partial<CollabFieldLockOptions> = {}) => {\n    if (!collabOptions.value.enabled || isUndefined(collabSocket.value)) return\n    lockWanted = null\n    const roomInfo = collabRoomInfoState.get(room)\n    if (roomInfo && roomInfo.status === CollabStatus.Inactive) {\n      if (!collabFieldDataBufferState.has(room)) {\n        collabFieldDataBufferState.set(room, new Map())\n      }\n      collabFieldDataBufferState.get(room)?.set(field, data)\n      // When the other editor leaves, this one still holds the lock\n      // on the server, so a returning editor finds the field locked.\n      // Release it there while connected. After a disconnect the server has already released it.\n      if (!collabSocket.value.connected || !fieldLockMaybeHeld(room, field, currentUserId.value)) return\n    }\n    collabSocket.value\n      ?.timeout(1000)\n      .emit('releaseFieldLock', room, field, data, options, (error, response: CollabChangeRoomLockCallbackTypes) => {\n        const statusEvent: CollabFieldLockStatusEvent = { field, room }\n        if (error || isCollabFailedChangeRoomLockCallback(response)) {\n          return void fieldLockStatusEventBus.emit(\n            statusEvent,\n            createFieldLockStatusPayload(CollabFieldLockType.Release, CollabFieldLockStatus.Failure)\n          )\n        }\n        if (isCollabSuccessChangeRoomLockCallback(response)) {\n          setFieldLockUnanswered(room, field, false)\n          if (!collabFieldLocksState.has(room)) {\n            collabFieldLocksState.set(room, new Map())\n          }\n          if (response.locks) {\n            for (const field of Object.keys(response.locks)) {\n              collabFieldLocksState.get(room)?.delete(field)\n            }\n          }\n\n          return void fieldLockStatusEventBus.emit(\n            statusEvent,\n            createFieldLockStatusPayload(CollabFieldLockType.Release, CollabFieldLockStatus.Success)\n          )\n        }\n      })\n  }\n\n  if (reacquireWhenActive) {\n    watch(\n      () => collabRoomInfoState.get(room)?.status,\n      (status, previous) => {\n        if (status !== CollabStatus.Active || previous === CollabStatus.Active || lockWanted === null) return\n        acquireCollabFieldLock(lockWanted)\n      }\n    )\n  }\n\n  const changeCollabFieldData = (data: CollabFieldData) => {\n    if (!collabOptions.value.enabled || isUndefined(collabSocket.value)) return\n    const roomInfo = collabRoomInfoState.get(room)\n    if (roomInfo && roomInfo.status === CollabStatus.Inactive) return\n    collabSocket.value.emit('changeFieldData', room, field, data, () => {\n      return\n    })\n  }\n\n  return {\n    addCollabFieldDataChangeListener,\n    addCollabFieldLockStatusListener,\n    addCollabGatheringBufferDataListener,\n    acquireCollabFieldLock,\n    releaseCollabFieldLock,\n    changeCollabFieldData,\n    lockedByUser,\n    collabFieldDataBufferState,\n    unsubscribeCollabFieldDataChangeListener,\n    unsubscribeCollabFieldLockStatusListener,\n    unsubscribeCollabGatheringBufferData,\n  }\n}\n"],"mappings":"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"}

package/dist/domains/collab/composables/collabHelpers.d.ts

@@ -0,0 +1,17 @@
+import { CollabFieldName, CollabRoom } from '../types/Collab';
+import { DocId, IntegerId } from '../../../shared/types/common';
+import { CachedItem } from '../../cached/composables/defineCached';
+import { AnzuUserMinimal } from '../../../shared/types/AnzuUser';
+export declare const COLLAB_FIELD_PREFIX_EMBED = "embed:";
+export declare const COLLAB_FIELD_PREFIX_COMMENT = "comment:";
+export type CollabCachedUsersMap = Map<IntegerId, CachedItem<AnzuUserMinimal>>;
+export declare function useCollabHelpers(): {
+    createCollabRoom: (id: IntegerId | DocId, entity: string, system: string) => CollabRoom;
+    createCollabFieldConfig: (name: CollabFieldName, room: CollabRoom, cachedUsers: CollabCachedUsersMap) => {
+        room: string;
+        field: string;
+        cachedUsers: CollabCachedUsersMap;
+    };
+    createCollabEmbedFieldName: (id: DocId) => CollabFieldName;
+    createCollabCommentFieldName: (id: DocId) => CollabFieldName;
+};

package/dist/domains/collab/composables/collabHelpers.js

@@ -0,0 +1,17 @@
+// src/domains/collab/composables/collabHelpers.ts
+var e = "embed:", t = "comment:";
+function n() {
+	return {
+		createCollabRoom: (e, t, n) => n + ":" + t + ":" + e,
+		createCollabFieldConfig: (e, t, n) => ({
+			room: t,
+			field: e,
+			cachedUsers: n
+		}),
+		createCollabEmbedFieldName: (t) => e + t,
+		createCollabCommentFieldName: (e) => t + e
+	};
+}
+export { t as COLLAB_FIELD_PREFIX_COMMENT, e as COLLAB_FIELD_PREFIX_EMBED, n as useCollabHelpers };
+
+//# sourceMappingURL=collabHelpers.js.map

package/dist/domains/collab/composables/collabHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collabHelpers.js","names":["COLLAB_FIELD_PREFIX_EMBED","COLLAB_FIELD_PREFIX_COMMENT","useCollabHelpers","system","entity","id","name"],"sources":["../../../../src/domains/collab/composables/collabHelpers.ts"],"sourcesContent":["import type { CollabFieldName, CollabRoom } from '@/domains/collab/types/Collab'\nimport type { DocId, IntegerId } from '@/shared/types/common'\nimport type { CachedItem } from '@/domains/cached/composables/defineCached'\nimport type { AnzuUserMinimal } from '@/shared/types/AnzuUser'\n\nexport const COLLAB_FIELD_PREFIX_EMBED = 'embed:'\nexport const COLLAB_FIELD_PREFIX_COMMENT = 'comment:'\n\nexport type CollabCachedUsersMap = Map<IntegerId, CachedItem<AnzuUserMinimal>>\n\nexport function useCollabHelpers() {\n  const createCollabRoom = (id: IntegerId | DocId, entity: string, system: string) => {\n    return (system + ':' + entity + ':' + id) as CollabRoom\n  }\n\n  const createCollabFieldConfig = (name: CollabFieldName, room: CollabRoom, cachedUsers: CollabCachedUsersMap) => {\n    return { room, field: name, cachedUsers }\n  }\n\n  const createCollabEmbedFieldName = (id: DocId) => {\n    return (COLLAB_FIELD_PREFIX_EMBED + id) as CollabFieldName\n  }\n\n  const createCollabCommentFieldName = (id: DocId) => {\n    return (COLLAB_FIELD_PREFIX_COMMENT + id) as CollabFieldName\n  }\n\n  return {\n    createCollabRoom,\n    createCollabFieldConfig,\n    createCollabEmbedFieldName,\n    createCollabCommentFieldName,\n  }\n}\n"],"mappings":";AAKA,IAAaA,IAA4B,UAC5BC,IAA8B;AAI3C,SAAgBC,IAAmB;CAiBjC,OAAO;EACL,mBAjBwB,GAAuB,GAAgB,MACvDC,IAAS,MAAMC,IAAS,MAAMC;EAiBtC,0BAd+B,GAAuB,GAAkB,OACjE;GAAE;GAAM,OAAOC;GAAM;EAAY;EAcxC,6BAXkC,MAC1BN,IAA4BK;EAWpC,+BARoC,MAC5BJ,IAA8BI;CAQxC;AACF"}

package/dist/domains/collab/composables/collabInit.d.ts

@@ -0,0 +1,3 @@
+export declare function useCollabInit(): {
+    initCollab: () => void;
+};

package/dist/domains/collab/composables/collabInit.js

@@ -0,0 +1,103 @@
+import { CollabStatus as e } from "../types/Collab.js";
+import { useCollabApprovedJoinRequestEventBus as t, useCollabApprovedRequestToTakeModerationEventBus as n, useCollabJoinRequestEventBus as r, useCollabKickedFromRoomEventBus as i, useCollabReconnectEventBus as a, useCollabRejectedJoinRequestEventBus as o, useCollabRejectedRequestToTakeModerationEventBus as s, useCollabRequestToTakeModerationEventBus as c, useCollabRoomDataChangeEventBus as l, useCollabStartingEventBus as u } from "./collabEventBus.js";
+import { useCollabStateInternal as d } from "./collabState.js";
+import { useCollabCurrentUserId as f } from "./collabCurrentUserId.js";
+import { createCollabRecovery as p } from "./collabRecovery.js";
+import { useAlerts as m } from "../../system/composables/alerts.js";
+import { useCommonAdminCollabOptions as h } from "./commonAdminCollabOptions.js";
+import { useSentry as g } from "../../system/composables/sentry.js";
+import { isNull as _ } from "../../../shared/utils/common.js";
+// src/domains/collab/composables/collabInit.ts
+function v() {
+	let { collabOptions: v } = h(), { showWarningT: y, showSuccessT: b } = m(), { collabConnected: x, collabSocket: S, collabConnectionState: C, setCollabRecover: w, collabRoomInfoState: T, collabFieldLocksState: E, collabFieldLocksUnanswered: D } = d(), { currentUserId: O } = f(), { logError: k } = g();
+	return { initCollab: () => {
+		let d = l(), f = a(), m = u(), h = r(), g = t(), A = o(), j = c(), M = n(), N = s(), P = i();
+		if (S.value || !v.value.enabled) return;
+		let F = v.value.io;
+		if (!F) k(/* @__PURE__ */ Error("Collab is enabled, but the plugin options pass no `io` from socket.io-client."));
+		else try {
+			S.value = F(v.value.socketUrl, {
+				transports: ["websocket"],
+				path: "/ws",
+				forceNew: !0,
+				auth: (e) => e({ userId: O.value })
+			});
+			let t = p({
+				socket: S.value,
+				state: C,
+				beforeReconnect: () => v.value.beforeReconnect(),
+				isSameIdentity: () => v.value.isSameIdentity?.(),
+				logError: k
+			});
+			w(t.retry), S.value.io?.on("reconnect_attempt", () => {
+				t.onReconnectAttempt() && (x.value = !1);
+			}), typeof window < "u" && (window.addEventListener("online", t.retryIfWaiting), document.addEventListener("visibilitychange", () => {
+				document.visibilityState === "visible" && t.retryIfWaiting();
+			}), window.addEventListener("pagehide", t.onPageHide), window.addEventListener("pageshow", (e) => t.onPageShow(e.persisted))), S.value.on("collabRoomChanged", (e) => {
+				try {
+					T.has(e.name) && T.set(e.name, e);
+				} catch (e) {
+					console.error("error", e);
+				}
+			}), S.value.on("collabRoomLocksChanged", (e, t) => {
+				if (!_(t)) {
+					let n = Object.entries(t);
+					E.has(e) && Object.keys(t).length !== 0 || E.set(e, new Map(n));
+					for (let [t, r] of n) r ? E.get(e)?.set(t, r) : E.get(e)?.delete(t);
+				}
+			}), S.value.on("collabRoomDataChanged", (e, t) => {
+				let n = Object.entries(t);
+				for (let [t, r] of n) d.emit({
+					room: e,
+					field: t
+				}, r);
+			}), S.value?.on("requestToJoin", (e, t, n) => {
+				h.emit({
+					room: e,
+					userId: t,
+					timestamp: n
+				});
+			}), S.value?.on("approvedRequestToJoin", (e) => {
+				g.emit({ room: e });
+			}), S.value?.on("rejectedRequestToJoin", (e) => {
+				A.emit({ room: e });
+			}), S.value?.on("requestToTakeModeration", (e, t, n) => {
+				j.emit({
+					room: e,
+					userId: t,
+					timestamp: n
+				});
+			}), S.value?.on("approvedRequestToTakeModeration", (e) => {
+				M.emit({ room: e });
+			}), S.value?.on("rejectedRequestToTakeModeration", (e) => {
+				N.emit({ room: e });
+			}), S.value?.on("transferredModeration", () => {
+				b("common.collab.alert.transferredModeration");
+			}), S.value?.on("kickedFromRoom", (e) => {
+				y("common.collab.alert.kickedFromRoom"), P.emit({ room: e });
+			}), S.value?.on("startCollab", async (e, t) => {
+				m.emit({
+					room: e,
+					startedCallback: t
+				});
+			}), S.value.on("connect", () => {
+				T.clear(), D.clear(), t.onConnect();
+				let e = x.value;
+				x.value = S.value?.connected ?? !1, e || f.emit("reconnect");
+			}), S.value.on("connect_error", (e) => {
+				if (x.value = S.value?.connected ?? !1, S.value?.active) return t.onTransportError();
+				t.onRefused(e);
+			}), S.value.on("disconnect", (n) => {
+				T.forEach((t) => t.status = e.Inactive), x.value = S.value?.connected ?? !1, t.onDisconnect(n);
+			});
+		} catch (e) {
+			k(e, {
+				level: "error",
+				tags: { collabPhase: "init" }
+			});
+		}
+	} };
+}
+export { v as useCollabInit };
+
+//# sourceMappingURL=collabInit.js.map

package/dist/domains/collab/composables/collabInit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collabInit.js","names":["useCollabInit","useCommonAdminCollabOptions","useAlerts","useCollabStateInternal","useCollabCurrentUserId","useSentry","changeEventBus","useCollabRoomDataChangeEventBus","reconnectEventBus","useCollabReconnectEventBus","collabStartingEventBus","useCollabStartingEventBus","requestAccessEventBus","useCollabJoinRequestEventBus","approvedJoinRequestEventBus","useCollabApprovedJoinRequestEventBus","rejectedJoinRequestEventBus","useCollabRejectedJoinRequestEventBus","requestToTakeModerationEventBus","useCollabRequestToTakeModerationEventBus","approvedRequestToTakeModerationEventBus","useCollabApprovedRequestToTakeModerationEventBus","rejectedRequestToTakeModerationEventBus","useCollabRejectedRequestToTakeModerationEventBus","kickedFromRoomEventBus","useCollabKickedFromRoomEventBus","collabSocket","collabOptions","io","callback","currentUserId","recovery","createCollabRecovery","collabConnectionState","setCollabRecover","event","collabRoomInfoState","room","error","isNull","locks","locksEntries","collabFieldLocksState","field","lock","dataEntries","data","fieldData","showWarningT","collabFieldLocksUnanswered","connectedBefore","collabConnected","CollabStatus","reason"],"sources":["../../../../src/domains/collab/composables/collabInit.ts"],"sourcesContent":["import type {\n  CollabRoom,\n  CollabRoomData,\n  CollabRoomInfo,\n  CollabRoomLocks,\n  CollabRoomPlainData,\n} from '@/domains/collab/types/Collab'\nimport { CollabStatus } from '@/domains/collab/types/Collab'\nimport {\n  useCollabApprovedJoinRequestEventBus,\n  useCollabApprovedRequestToTakeModerationEventBus,\n  useCollabJoinRequestEventBus,\n  useCollabKickedFromRoomEventBus,\n  useCollabReconnectEventBus,\n  useCollabRejectedJoinRequestEventBus,\n  useCollabRejectedRequestToTakeModerationEventBus,\n  useCollabRequestToTakeModerationEventBus,\n  useCollabRoomDataChangeEventBus,\n  useCollabStartingEventBus,\n} from '@/domains/collab/composables/collabEventBus'\nimport { useCollabStateInternal } from '@/domains/collab/composables/collabState'\nimport { useCollabCurrentUserId } from '@/domains/collab/composables/collabCurrentUserId'\nimport { type CollabRefusal, createCollabRecovery } from '@/domains/collab/composables/collabRecovery'\nimport { useAlerts } from '@/domains/system/composables/alerts'\nimport { useCommonAdminCollabOptions } from '@/domains/collab/composables/commonAdminCollabOptions'\nimport { useSentry } from '@/domains/system/composables/sentry'\nimport { isNull } from '@/shared/utils/common'\n\nexport function useCollabInit() {\n  const { collabOptions } = useCommonAdminCollabOptions()\n  const { showWarningT, showSuccessT } = useAlerts()\n  const {\n    collabConnected,\n    collabSocket,\n    collabConnectionState,\n    setCollabRecover,\n    collabRoomInfoState,\n    collabFieldLocksState,\n    collabFieldLocksUnanswered,\n  } = useCollabStateInternal()\n  const { currentUserId } = useCollabCurrentUserId()\n\n  const { logError } = useSentry()\n\n  const initCollab = () => {\n    const changeEventBus = useCollabRoomDataChangeEventBus()\n    const reconnectEventBus = useCollabReconnectEventBus()\n    const collabStartingEventBus = useCollabStartingEventBus()\n    const requestAccessEventBus = useCollabJoinRequestEventBus()\n    const approvedJoinRequestEventBus = useCollabApprovedJoinRequestEventBus()\n    const rejectedJoinRequestEventBus = useCollabRejectedJoinRequestEventBus()\n    const requestToTakeModerationEventBus = useCollabRequestToTakeModerationEventBus()\n    const approvedRequestToTakeModerationEventBus = useCollabApprovedRequestToTakeModerationEventBus()\n    const rejectedRequestToTakeModerationEventBus = useCollabRejectedRequestToTakeModerationEventBus()\n    const kickedFromRoomEventBus = useCollabKickedFromRoomEventBus()\n\n    if (collabSocket.value || !collabOptions.value.enabled) {\n      return\n    }\n    const io = collabOptions.value.io\n    if (!io) {\n      logError(new Error('Collab is enabled, but the plugin options pass no `io` from socket.io-client.'))\n      return\n    }\n\n    try {\n      collabSocket.value = io(collabOptions.value.socketUrl, {\n        transports: ['websocket'],\n        path: '/ws',\n        forceNew: true,\n        // Read for every handshake: the server refuses cookies of another account than the page belongs to.\n        auth: (callback) => callback({ userId: currentUserId.value }),\n      })\n      const recovery = createCollabRecovery({\n        socket: collabSocket.value,\n        state: collabConnectionState,\n        beforeReconnect: () => collabOptions.value.beforeReconnect(),\n        isSameIdentity: () => collabOptions.value.isSameIdentity?.(),\n        logError,\n      })\n      setCollabRecover(recovery.retry)\n      // Optional: the test doubles of the socket have no manager.\n      collabSocket.value.io?.on('reconnect_attempt', () => {\n        if (recovery.onReconnectAttempt()) collabConnected.value = false\n      })\n      if (typeof window !== 'undefined') {\n        window.addEventListener('online', recovery.retryIfWaiting)\n        document.addEventListener('visibilitychange', () => {\n          if (document.visibilityState === 'visible') recovery.retryIfWaiting()\n        })\n        window.addEventListener('pagehide', recovery.onPageHide)\n        window.addEventListener('pageshow', (event) => recovery.onPageShow(event.persisted))\n      }\n      collabSocket.value.on('collabRoomChanged', (room: CollabRoomInfo) => {\n        try {\n          if (collabRoomInfoState.has(room.name)) {\n            collabRoomInfoState.set(room.name, room)\n          }\n        } catch (error) {\n          console.error('error', error)\n        }\n      })\n      collabSocket.value.on('collabRoomLocksChanged', (room: CollabRoom, locks: CollabRoomLocks | null) => {\n        if (!isNull(locks)) {\n          const locksEntries = Object.entries(locks)\n          if (!collabFieldLocksState.has(room) || Object.keys(locks).length === 0) {\n            collabFieldLocksState.set(room, new Map(locksEntries))\n          }\n          for (const [field, lock] of locksEntries) {\n            if (!lock) {\n              collabFieldLocksState.get(room)?.delete(field)\n              continue\n            }\n            collabFieldLocksState.get(room)?.set(field, lock)\n          }\n        }\n      })\n      collabSocket.value.on('collabRoomDataChanged', (room: CollabRoom, data: CollabRoomData) => {\n        const dataEntries = Object.entries(data)\n        for (const [field, fieldData] of dataEntries) {\n          changeEventBus.emit({ room, field }, fieldData)\n        }\n      })\n      collabSocket.value?.on('requestToJoin', (room: CollabRoom, userId: number, timestamp: number) => {\n        requestAccessEventBus.emit({ room, userId, timestamp })\n      })\n      collabSocket.value?.on('approvedRequestToJoin', (room: CollabRoom) => {\n        approvedJoinRequestEventBus.emit({ room })\n      })\n      collabSocket.value?.on('rejectedRequestToJoin', (room: CollabRoom) => {\n        rejectedJoinRequestEventBus.emit({ room })\n      })\n      collabSocket.value?.on('requestToTakeModeration', (room: CollabRoom, userId: number, timestamp: number) => {\n        requestToTakeModerationEventBus.emit({ room, userId, timestamp })\n      })\n      collabSocket.value?.on('approvedRequestToTakeModeration', (room: CollabRoom) => {\n        approvedRequestToTakeModerationEventBus.emit({ room })\n      })\n      collabSocket.value?.on('rejectedRequestToTakeModeration', (room: CollabRoom) => {\n        rejectedRequestToTakeModerationEventBus.emit({ room })\n      })\n      collabSocket.value?.on('transferredModeration', () => {\n        showSuccessT('common.collab.alert.transferredModeration')\n      })\n      collabSocket.value?.on('kickedFromRoom', (room: CollabRoom) => {\n        showWarningT('common.collab.alert.kickedFromRoom')\n        kickedFromRoomEventBus.emit({ room })\n      })\n      collabSocket.value?.on('startCollab', async (room, callback: (data: CollabRoomPlainData) => void) => {\n        collabStartingEventBus.emit({ room, startedCallback: callback })\n      })\n      collabSocket.value.on('connect', () => {\n        /* Memberships from before a reconnect are stale; the server does not re-announce them.\n         *\n         * The write claims behind them are deliberately left alone. Socket.io drops the\n         * acknowledgement of a packet it already put on the wire (`_clearAcks`), so one emitted\n         * before the reconnect can no longer land here — but it keeps the acknowledgement of a\n         * packet still in `sendBuffer`, which it delivers on this connection. Resetting the claims\n         * would discard exactly those: a join emitted while the socket was still connecting is\n         * flushed just before this handler runs, and its acknowledgement arrives a round trip\n         * later to find its claim gone. */\n        collabRoomInfoState.clear()\n        // The server released the old connection's locks, and timed-out requests were dropped from the send buffer.\n        collabFieldLocksUnanswered.clear()\n        recovery.onConnect()\n        const connectedBefore = collabConnected.value\n        collabConnected.value = collabSocket.value?.connected ?? false\n        if (!connectedBefore) reconnectEventBus.emit('reconnect')\n      })\n      collabSocket.value.on('connect_error', (error: CollabRefusal) => {\n        collabConnected.value = collabSocket.value?.connected ?? false\n        // Still `active`: a transport error, socket.io reconnects on its own. Otherwise the server refused it.\n        if (collabSocket.value?.active) return recovery.onTransportError()\n        recovery.onRefused(error)\n      })\n      collabSocket.value.on('disconnect', (reason) => {\n        collabRoomInfoState.forEach((roomInfo: CollabRoomInfo) => (roomInfo.status = CollabStatus.Inactive))\n        collabConnected.value = collabSocket.value?.connected ?? false\n        recovery.onDisconnect(reason)\n      })\n    } catch (error) {\n      // Not `message`: with `level` beside it Sentry reads the object as scope data and drops the key.\n      logError(error as Error, { level: 'error', tags: { collabPhase: 'init' } })\n    }\n  }\n\n  return {\n    initCollab,\n  }\n}\n"],"mappings":"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"}

package/dist/domains/collab/composables/collabRecovery.d.ts

@@ -0,0 +1,49 @@
+import { Ref } from 'vue';
+import { CollabConnectionStateType } from '../types/Collab';
+export declare const COLLAB_RETRY_DELAYS_MS: number[];
+export declare const COLLAB_BEFORE_RECONNECT_TIMEOUT_MS = 20000;
+export declare const COLLAB_STUCK_REPORT_MS: number;
+export type CollabRefusal = Error & {
+    data?: {
+        reason?: string;
+    };
+};
+interface CollabRecoverySocket {
+    readonly connected: boolean;
+    readonly active: boolean;
+    connect: () => unknown;
+    disconnect: () => unknown;
+}
+interface CollabRecoveryOptions {
+    socket: CollabRecoverySocket;
+    state: Ref<CollabConnectionStateType>;
+    beforeReconnect: () => unknown;
+    isSameIdentity: () => boolean | undefined;
+    logError: (error: Error, context: {
+        level: 'error' | 'warning';
+        tags: Record<string, string>;
+        fingerprint?: string[];
+    }) => void;
+}
+/**
+ * Brings a socket the server refused back, once per refusal and never under another account.
+ *
+ * Transport errors are socket.io's: it reconnects on its own, and nothing here runs for them. A refusal (the
+ * server's `connect_error`, after which the socket is no longer `active`) asks `beforeReconnect` what to do and
+ * connects the same socket again only on `ready`. A token refresh spent on a transport error used to leave the
+ * refusal that followed it, typically after a night, with nothing to recover by.
+ */
+export declare function createCollabRecovery({ socket, state, beforeReconnect, isSameIdentity, logError, }: CollabRecoveryOptions): {
+    /** The user's "try again": also out of a terminal state, with the retry delays and the refusals counted anew. */
+    retry: () => Promise<void>;
+    retryIfWaiting: () => void;
+    onTransportError: () => void;
+    onRefused: (error: CollabRefusal) => void;
+    onConnect: () => void;
+    onDisconnect: (reason: string) => void;
+    /** socket.io reconnects without `beforeReconnect`; stop it before cookies of another account are sent. */
+    onReconnectAttempt: () => boolean;
+    onPageHide: () => void;
+    onPageShow: (persisted: boolean) => void;
+};
+export {};