stop manual status from auto-reverting to a previous claim

Author: ricardogarim

ee/packages/presence/src/Presence.spec.ts

@@ -111,7 +111,12 @@ describe('Presence class', () => {
 				statusExpiresAt: expiresAt,
 			});
 
-			expect(updatePresenceMock).toHaveBeenCalledWith('u1', expect.objectContaining({ statusExpiresAt: expiresAt }), undefined, undefined);
+			expect(updatePresenceMock).toHaveBeenCalledWith(
+				'u1',
+				expect.objectContaining({ statusExpiresAt: expiresAt }),
+				expect.arrayContaining(['previousState']),
+				undefined,
+			);
 		});
 	});
 

ee/packages/presence/src/lib/presenceEngine.spec.ts

@@ -163,15 +163,47 @@ describe('processPresence', () => {
 			expect(result.values).toStrictEqual({});
 		});
 
-		test('should apply higher priority over external and save external as previousState', () => {
+		test('should apply manual over external without stashing the displaced claim', () => {
 			const result = processPresence(
 				user({ statusSource: 'external', statusDefault: UserStatus.BUSY, statusText: 'In a meeting' }),
 				[session()],
 				{ type: 'setActive', newState: { statusDefault: UserStatus.BUSY, statusText: 'Focusing', statusSource: 'manual' } },
 			);
 			expect(result.values.statusSource).toBe('manual');
 			expect(result.values.statusText).toBe('Focusing');
-			expect(result.values.previousState).toMatchObject({ statusSource: 'external', statusText: 'In a meeting' });
+			expect(result.values.previousState).toBeUndefined();
+			expect(result.clear).toContain('previousState');
+		});
+
+		test('should drop a queued previousState when a manual claim wins', () => {
+			const result = processPresence(
+				user({
+					statusSource: 'external',
+					statusDefault: UserStatus.BUSY,
+					statusText: 'In a meeting',
+					previousState: { statusDefault: UserStatus.AWAY, statusText: 'Lunch', statusSource: 'manual' },
+				}),
+				[session()],
+				{ type: 'setActive', newState: { statusDefault: UserStatus.BUSY, statusText: 'Focusing', statusSource: 'manual' } },
+			);
+			expect(result.values.statusSource).toBe('manual');
+			expect(result.values.previousState).toBeUndefined();
+			expect(result.clear).toContain('previousState');
+		});
+
+		test('should clear a queued previousState when overwriting a same-source manual claim', () => {
+			const result = processPresence(
+				user({
+					statusSource: 'manual',
+					statusDefault: UserStatus.BUSY,
+					statusText: 'Focusing',
+					previousState: { statusDefault: UserStatus.AWAY, statusText: 'Lunch', statusSource: 'external' },
+				}),
+				[session()],
+				{ type: 'setActive', newState: { statusDefault: UserStatus.AWAY, statusText: 'Heads down', statusSource: 'manual' } },
+			);
+			expect(result.values.statusText).toBe('Heads down');
+			expect(result.clear).toContain('previousState');
 		});
 	});
 

ee/packages/presence/src/lib/presenceEngine.ts

@@ -95,16 +95,21 @@ function resolveIntent(
 	const currentPriority = user.statusSource ? PRIORITY[user.statusSource] : NO_PRIORITY;
 	const newPriority = newState.statusSource ? PRIORITY[newState.statusSource] : NO_PRIORITY;
 
-	// higher priority -> save current as previous and apply new
+	// a manual claim is the user's explicit intent: when it wins it doesn't stash the
+	// displaced claim and clears any queued one, so it never gets auto-reverted.
+	const isManual = newState.statusSource === 'manual';
+
+	// higher priority -> apply new; stash displaced claim unless the new claim is manual
 	if (newPriority < currentPriority) {
-		const previousState = user.statusSource
-			? {
-					statusDefault: currentStatusDefault,
-					statusText: user.statusText ?? '',
-					statusSource: user.statusSource,
-					statusExpiresAt: user.statusExpiresAt,
-				}
-			: undefined;
+		const previousState =
+			!isManual && user.statusSource
+				? {
+						statusDefault: currentStatusDefault,
+						statusText: user.statusText ?? '',
+						statusSource: user.statusSource,
+						statusExpiresAt: user.statusExpiresAt,
+					}
+				: undefined;
 
 		return {
 			set: {
@@ -114,11 +119,11 @@ function resolveIntent(
 				...(newState.statusExpiresAt && { statusExpiresAt: newState.statusExpiresAt }),
 				...(previousState && { previousState }),
 			},
-			unset: fieldsToUnset(newState),
+			unset: fieldsToUnset(newState, isManual ? ['previousState'] : []),
 		};
 	}
 
-	// same priority -> overwrite and keep previous
+	// same priority -> overwrite; manual also drops any queued previous
 	if (newPriority === currentPriority) {
 		return {
 			set: {
@@ -127,7 +132,7 @@ function resolveIntent(
 				...(newState.statusText != null && { statusText: newState.statusText }),
 				...(newState.statusExpiresAt && { statusExpiresAt: newState.statusExpiresAt }),
 			},
-			unset: fieldsToUnset(newState),
+			unset: fieldsToUnset(newState, isManual ? ['previousState'] : []),
 		};
 	}