[lib] Use "your message" for reaction MessagePreview
ClosedPublic
Actions

Authored by ashoat on Feb 11 2025, 12:30 AM.

Details

Reviewers

tomek
angelika

Commits

rCOMMd3204b9ecadf: [lib] Use "your message" for reaction MessagePreview

Summary

See inline code comment.

Depends on D14346

Test Plan

Confirm "a message" is replaced by "your message" in MessagePreview.

Diff Detail

Repository

rCOMM Comm

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

ashoat created this revision.Feb 11 2025, 12:30 AM

Harbormaster completed remote builds in B33463: Diff 46995.Feb 11 2025, 2:54 AM

ashoat requested review of this revision.Feb 11 2025, 2:54 AM

tomek accepted this revision.Feb 12 2025, 5:31 AM

This revision is now accepted and ready to land.Feb 12 2025, 5:31 AM

Rebase

Harbormaster completed remote builds in B33480: Diff 47020.Feb 12 2025, 5:57 AM

Closed by commit rCOMMd3204b9ecadf: [lib] Use "your message" for reaction MessagePreview (authored by ashoat). · Explain WhyFeb 12 2025, 5:59 AM

This revision was automatically updated to reflect the committed changes.

ashoat added a commit: rCOMMd3204b9ecadf: [lib] Use "your message" for reaction MessagePreview.

Revision Contents
Changeset List

Path

Size

lib/

shared/

messages/

reaction-message-spec.js

8 lines

Diff 46995

View Options

lib/shared/messages/reaction-message-spec.js

Show All 34 Lines	import {
newThreadActionTypes,		newThreadActionTypes,
} from '../actions/thread-actions.js';		} from '../actions/thread-actions.js';
import {		import {
keyserverAuthActionTypes,		keyserverAuthActionTypes,
deleteKeyserverAccountActionTypes,		deleteKeyserverAccountActionTypes,
legacyLogInActionTypes,		legacyLogInActionTypes,
} from '../actions/user-actions.js';		} from '../actions/user-actions.js';
import { setNewSessionActionType } from '../keyserver-conn/keyserver-conn-types.js';		import { setNewSessionActionType } from '../keyserver-conn/keyserver-conn-types.js';
		import type { EntryStoreOperation } from '../ops/entries-store-ops.js';
import { entryID } from '../shared/entry-utils.js';		import { entryID } from '../shared/entry-utils.js';
import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';		import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
import { threadInFilterList } from '../shared/thread-utils.js';		import { threadInFilterList } from '../shared/thread-utils.js';
import { updateSpecs } from '../shared/updates/update-specs.js';		import { updateSpecs } from '../shared/updates/update-specs.js';
import type { RawEntryInfo, EntryStore } from '../types/entry-types.js';		import type { RawEntryInfo, EntryStore } from '../types/entry-types.js';
import type { BaseAction } from '../types/redux-types.js';		import type { BaseAction } from '../types/redux-types.js';
import { type ClientEntryInconsistencyReportCreationRequest } from '../types/report-types.js';		import { type ClientEntryInconsistencyReportCreationRequest } from '../types/report-types.js';
import {		import {
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines	) {
const entryInfos = someEntryUpdated ? mergedEntryInfos : currentEntryInfos;		const entryInfos = someEntryUpdated ? mergedEntryInfos : currentEntryInfos;
return [entryInfos, daysToEntries];		return [entryInfos, daysToEntries];
}		}

function reduceEntryInfos(		function reduceEntryInfos(
entryStore: EntryStore,		entryStore: EntryStore,
action: BaseAction,		action: BaseAction,
newThreadInfos: RawThreadInfos,		newThreadInfos: RawThreadInfos,
): [EntryStore, $ReadOnlyArray<ClientEntryInconsistencyReportCreationRequest>] {		): {
		+entryStore: EntryStore,
		+entryStoreOperations: $ReadOnlyArray<EntryStoreOperation>,
		+reportCreationRequests: $ReadOnlyArray<ClientEntryInconsistencyReportCreationRequest>,
		} {
const { entryInfos, daysToEntries, lastUserInteractionCalendar } = entryStore;		const { entryInfos, daysToEntries, lastUserInteractionCalendar } = entryStore;
if (		if (
action.type === deleteKeyserverAccountActionTypes.success \|\|		action.type === deleteKeyserverAccountActionTypes.success \|\|
action.type === deleteThreadActionTypes.success \|\|		action.type === deleteThreadActionTypes.success \|\|
action.type === leaveThreadActionTypes.success		action.type === leaveThreadActionTypes.success
) {		) {
const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);		const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);
const newEntryInfos = _pickBy(		const newEntryInfos = _pickBy(
(entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],		(entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],
)(entryInfos);		)(entryInfos);

if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {		if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {
return [		return {
{		entryStore: {
entryInfos,		entryInfos,
daysToEntries,		daysToEntries,
lastUserInteractionCalendar,		lastUserInteractionCalendar,
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
}		}
const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(		const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(
daysToEntries,		daysToEntries,
newEntryInfos,		newEntryInfos,
);		);
return [		return {
{		entryStore: {
entryInfos: newEntryInfos,		entryInfos: newEntryInfos,
daysToEntries: newDaysToEntries,		daysToEntries: newDaysToEntries,
lastUserInteractionCalendar,		lastUserInteractionCalendar,
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (action.type === setNewSessionActionType) {		} else if (action.type === setNewSessionActionType) {
const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);		const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);
const newEntryInfos = _pickBy(		const newEntryInfos = _pickBy(
(entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],		(entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],
)(entryInfos);		)(entryInfos);
const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(		const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(
daysToEntries,		daysToEntries,
newEntryInfos,		newEntryInfos,
);		);
let newLastUserInteractionCalendar = lastUserInteractionCalendar;		let newLastUserInteractionCalendar = lastUserInteractionCalendar;
if (		if (
action.payload.sessionChange.cookieInvalidated &&		action.payload.sessionChange.cookieInvalidated &&
action.payload.keyserverID === authoritativeKeyserverID() &&		action.payload.keyserverID === authoritativeKeyserverID() &&
relyingOnAuthoritativeKeyserver		relyingOnAuthoritativeKeyserver
) {		) {
newLastUserInteractionCalendar = 0;		newLastUserInteractionCalendar = 0;
}		}

if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {		if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {
return [		return {
{		entryStore: {
entryInfos,		entryInfos,
daysToEntries,		daysToEntries,
lastUserInteractionCalendar: newLastUserInteractionCalendar,		lastUserInteractionCalendar: newLastUserInteractionCalendar,
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
}		}
return [		return {
{		entryStore: {
entryInfos: newEntryInfos,		entryInfos: newEntryInfos,
daysToEntries: newDaysToEntries,		daysToEntries: newDaysToEntries,
lastUserInteractionCalendar: newLastUserInteractionCalendar,		lastUserInteractionCalendar: newLastUserInteractionCalendar,
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (action.type === fetchEntriesActionTypes.success) {		} else if (action.type === fetchEntriesActionTypes.success) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(		const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos,		entryInfos,
daysToEntries,		daysToEntries,
action.payload.rawEntryInfos,		action.payload.rawEntryInfos,
newThreadInfos,		newThreadInfos,
);		);
return [		return {
{		entryStore: {
entryInfos: updatedEntryInfos,		entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries,		daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar,		lastUserInteractionCalendar,
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (		} else if (
action.type === updateCalendarQueryActionTypes.started &&		action.type === updateCalendarQueryActionTypes.started &&
action.payload &&		action.payload &&
action.payload.calendarQuery		action.payload.calendarQuery
) {		) {
return [		return {
{		entryStore: {
entryInfos,		entryInfos,
daysToEntries,		daysToEntries,
lastUserInteractionCalendar: Date.now(),		lastUserInteractionCalendar: Date.now(),
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (action.type === updateCalendarQueryActionTypes.success) {		} else if (action.type === updateCalendarQueryActionTypes.success) {
const newLastUserInteractionCalendar = action.payload.calendarQuery		const newLastUserInteractionCalendar = action.payload.calendarQuery
? Date.now()		? Date.now()
: lastUserInteractionCalendar;		: lastUserInteractionCalendar;
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(		const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos,		entryInfos,
daysToEntries,		daysToEntries,
action.payload.rawEntryInfos,		action.payload.rawEntryInfos,
newThreadInfos,		newThreadInfos,
);		);
const deletionMarkedEntryInfos = markDeletedEntries(		const deletionMarkedEntryInfos = markDeletedEntries(
updatedEntryInfos,		updatedEntryInfos,
action.payload.deletedEntryIDs,		action.payload.deletedEntryIDs,
);		);
return [		return {
{		entryStore: {
entryInfos: deletionMarkedEntryInfos,		entryInfos: deletionMarkedEntryInfos,
daysToEntries: updatedDaysToEntries,		daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar: newLastUserInteractionCalendar,		lastUserInteractionCalendar: newLastUserInteractionCalendar,
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (action.type === createLocalEntryActionType) {		} else if (action.type === createLocalEntryActionType) {
const entryInfo = action.payload;		const entryInfo = action.payload;
const localID = entryInfo.localID;		const localID = entryInfo.localID;
invariant(localID, 'localID should be set in CREATE_LOCAL_ENTRY');		invariant(localID, 'localID should be set in CREATE_LOCAL_ENTRY');
const newEntryInfos = {		const newEntryInfos = {
...entryInfos,		...entryInfos,
[(localID: string)]: entryInfo,		[(localID: string)]: entryInfo,
};		};
const dayString = dateString(		const dayString = dateString(
entryInfo.year,		entryInfo.year,
entryInfo.month,		entryInfo.month,
entryInfo.day,		entryInfo.day,
);		);
const newDaysToEntries = {		const newDaysToEntries = {
...daysToEntries,		...daysToEntries,
[dayString]: _union([localID])(daysToEntries[dayString]),		[dayString]: _union([localID])(daysToEntries[dayString]),
};		};
return [		return {
{		entryStore: {
entryInfos: newEntryInfos,		entryInfos: newEntryInfos,
daysToEntries: newDaysToEntries,		daysToEntries: newDaysToEntries,
lastUserInteractionCalendar: Date.now(),		lastUserInteractionCalendar: Date.now(),
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (action.type === createEntryActionTypes.success) {		} else if (action.type === createEntryActionTypes.success) {
const localID = action.payload.localID;		const localID = action.payload.localID;
const serverID = action.payload.entryID;		const serverID = action.payload.entryID;
// If an entry with this serverID already got into the store somehow		// If an entry with this serverID already got into the store somehow
// (likely through an unrelated request), we need to dedup them.		// (likely through an unrelated request), we need to dedup them.
let rekeyedEntryInfos;		let rekeyedEntryInfos;
if (entryInfos[serverID]) {		if (entryInfos[serverID]) {
// It's fair to assume the serverID entry is newer than the localID		// It's fair to assume the serverID entry is newer than the localID
// entry, and this probably won't happen often, so for now we can just		// entry, and this probably won't happen often, so for now we can just
// keep the serverID entry.		// keep the serverID entry.
rekeyedEntryInfos = _omitBy(		rekeyedEntryInfos = _omitBy(
(candidate: RawEntryInfo) =>		(candidate: RawEntryInfo) =>
!candidate.id && candidate.localID === localID,		!candidate.id && candidate.localID === localID,
)(entryInfos);		)(entryInfos);
} else if (entryInfos[localID]) {		} else if (entryInfos[localID]) {
rekeyedEntryInfos = _mapKeys((oldKey: string) =>		rekeyedEntryInfos = _mapKeys((oldKey: string) =>
entryInfos[oldKey].localID === localID ? serverID : oldKey,		entryInfos[oldKey].localID === localID ? serverID : oldKey,
)(entryInfos);		)(entryInfos);
} else {		} else {
// This happens if the entry is deauthorized before it's saved		// This happens if the entry is deauthorized before it's saved
return [entryStore, []];		return {
		entryStore,
		entryStoreOperations: [],
		reportCreationRequests: [],
		};
}		}

const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(		const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
rekeyedEntryInfos,		rekeyedEntryInfos,
null,		null,
mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),		mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),
newThreadInfos,		newThreadInfos,
);		);
		return {
return [		entryStore: {
{
entryInfos: updatedEntryInfos,		entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries,		daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar: Date.now(),		lastUserInteractionCalendar: Date.now(),
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (action.type === saveEntryActionTypes.success) {		} else if (action.type === saveEntryActionTypes.success) {
const serverID = action.payload.entryID;		const serverID = action.payload.entryID;
if (		if (
!entryInfos[serverID] \|\|		!entryInfos[serverID] \|\|
!threadInFilterList(newThreadInfos[entryInfos[serverID].threadID])		!threadInFilterList(newThreadInfos[entryInfos[serverID].threadID])
) {		) {
// This happens if the entry is deauthorized before it's saved		// This happens if the entry is deauthorized before it's saved
return [entryStore, []];		return {
		entryStore,
		entryStoreOperations: [],
		reportCreationRequests: [],
		};
}		}

const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(		const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos,		entryInfos,
daysToEntries,		daysToEntries,
mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),		mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),
newThreadInfos,		newThreadInfos,
);		);

return [		return {
{		entryStore: {
entryInfos: updatedEntryInfos,		entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries,		daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar: Date.now(),		lastUserInteractionCalendar: Date.now(),
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (action.type === concurrentModificationResetActionType) {		} else if (action.type === concurrentModificationResetActionType) {
const { payload } = action;		const { payload } = action;
if (		if (
!entryInfos[payload.id] \|\|		!entryInfos[payload.id] \|\|
!threadInFilterList(newThreadInfos[entryInfos[payload.id].threadID])		!threadInFilterList(newThreadInfos[entryInfos[payload.id].threadID])
) {		) {
// This happens if the entry is deauthorized before it's restored		// This happens if the entry is deauthorized before it's restored
return [entryStore, []];		return {
		entryStore,
		entryStoreOperations: [],
		reportCreationRequests: [],
		};
}		}
const newEntryInfos = {		const newEntryInfos = {
...entryInfos,		...entryInfos,
[payload.id]: {		[payload.id]: {
...entryInfos[payload.id],		...entryInfos[payload.id],
text: payload.dbText,		text: payload.dbText,
},		},
};		};
return [		return {
{		entryStore: {
entryInfos: newEntryInfos,		entryInfos: newEntryInfos,
daysToEntries,		daysToEntries,
lastUserInteractionCalendar,		lastUserInteractionCalendar,
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (action.type === deleteEntryActionTypes.started) {		} else if (action.type === deleteEntryActionTypes.started) {
const payload = action.payload;		const payload = action.payload;
const id =		const id =
payload.serverID && entryInfos[payload.serverID]		payload.serverID && entryInfos[payload.serverID]
? payload.serverID		? payload.serverID
: payload.localID;		: payload.localID;
invariant(id, 'either serverID or localID should be set');		invariant(id, 'either serverID or localID should be set');
const newEntryInfos = {		const newEntryInfos = {
...entryInfos,		...entryInfos,
[(id: string)]: {		[(id: string)]: {
...entryInfos[id],		...entryInfos[id],
deleted: true,		deleted: true,
},		},
};		};
return [		return {
{		entryStore: {
entryInfos: newEntryInfos,		entryInfos: newEntryInfos,
daysToEntries,		daysToEntries,
lastUserInteractionCalendar: Date.now(),		lastUserInteractionCalendar: Date.now(),
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (action.type === deleteEntryActionTypes.success) {		} else if (action.type === deleteEntryActionTypes.success) {
const { payload } = action;		const { payload } = action;
if (payload) {		if (payload) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(		const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos,		entryInfos,
daysToEntries,		daysToEntries,
mergeUpdateEntryInfos([], payload.updatesResult.viewerUpdates),		mergeUpdateEntryInfos([], payload.updatesResult.viewerUpdates),
newThreadInfos,		newThreadInfos,
);		);
return [		return {
{		entryStore: {
entryInfos: updatedEntryInfos,		entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries,		daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar,		lastUserInteractionCalendar,
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
}		}
} else if (action.type === fetchRevisionsForEntryActionTypes.success) {		} else if (action.type === fetchRevisionsForEntryActionTypes.success) {
const id = action.payload.entryID;		const id = action.payload.entryID;
if (		if (
!entryInfos[id] \|\|		!entryInfos[id] \|\|
!threadInFilterList(newThreadInfos[entryInfos[id].threadID])		!threadInFilterList(newThreadInfos[entryInfos[id].threadID])
) {		) {
// This happens if the entry is deauthorized before it's restored		// This happens if the entry is deauthorized before it's restored
return [entryStore, []];		return {
		entryStore,
		entryStoreOperations: [],
		reportCreationRequests: [],
		};
}		}
// Make sure the entry is in sync with its latest revision		// Make sure the entry is in sync with its latest revision
const newEntryInfos = {		const newEntryInfos = {
...entryInfos,		...entryInfos,
[id]: {		[id]: {
...entryInfos[id],		...entryInfos[id],
text: action.payload.text,		text: action.payload.text,
deleted: action.payload.deleted,		deleted: action.payload.deleted,
},		},
};		};
return [		return {
{		entryStore: {
entryInfos: newEntryInfos,		entryInfos: newEntryInfos,
daysToEntries,		daysToEntries,
lastUserInteractionCalendar,		lastUserInteractionCalendar,
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (action.type === restoreEntryActionTypes.success) {		} else if (action.type === restoreEntryActionTypes.success) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(		const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos,		entryInfos,
daysToEntries,		daysToEntries,
mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),		mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),
newThreadInfos,		newThreadInfos,
);		);
return [		return {
{		entryStore: {
entryInfos: updatedEntryInfos,		entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries,		daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar: Date.now(),		lastUserInteractionCalendar: Date.now(),
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (		} else if (
action.type === legacyLogInActionTypes.success \|\|		action.type === legacyLogInActionTypes.success \|\|
action.type === legacySiweAuthActionTypes.success \|\|		action.type === legacySiweAuthActionTypes.success \|\|
action.type === keyserverAuthActionTypes.success		action.type === keyserverAuthActionTypes.success
) {		) {
const { calendarResult } = action.payload;		const { calendarResult } = action.payload;
if (calendarResult) {		if (calendarResult) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(		const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos,		entryInfos,
daysToEntries,		daysToEntries,
calendarResult.rawEntryInfos,		calendarResult.rawEntryInfos,
newThreadInfos,		newThreadInfos,
);		);
return [		return {
{		entryStore: {
entryInfos: updatedEntryInfos,		entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries,		daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar,		lastUserInteractionCalendar,
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
}		}
} else if (action.type === incrementalStateSyncActionType) {		} else if (action.type === incrementalStateSyncActionType) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(		const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos,		entryInfos,
daysToEntries,		daysToEntries,
mergeUpdateEntryInfos(		mergeUpdateEntryInfos(
action.payload.deltaEntryInfos,		action.payload.deltaEntryInfos,
action.payload.updatesResult.newUpdates,		action.payload.updatesResult.newUpdates,
),		),
newThreadInfos,		newThreadInfos,
);		);
const deletionMarkedEntryInfos = markDeletedEntries(		const deletionMarkedEntryInfos = markDeletedEntries(
updatedEntryInfos,		updatedEntryInfos,
action.payload.deletedEntryIDs,		action.payload.deletedEntryIDs,
);		);
return [		return {
{		entryStore: {
entryInfos: deletionMarkedEntryInfos,		entryInfos: deletionMarkedEntryInfos,
daysToEntries: updatedDaysToEntries,		daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar,		lastUserInteractionCalendar,
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (		} else if (
action.type === processUpdatesActionType \|\|		action.type === processUpdatesActionType \|\|
action.type === joinThreadActionTypes.success \|\|		action.type === joinThreadActionTypes.success \|\|
action.type === newThreadActionTypes.success		action.type === newThreadActionTypes.success
) {		) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(		const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos,		entryInfos,
daysToEntries,		daysToEntries,
mergeUpdateEntryInfos([], action.payload.updatesResult.newUpdates),		mergeUpdateEntryInfos([], action.payload.updatesResult.newUpdates),
newThreadInfos,		newThreadInfos,
);		);
return [		return {
{		entryStore: {
entryInfos: updatedEntryInfos,		entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries,		daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar,		lastUserInteractionCalendar,
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (action.type === fullStateSyncActionType) {		} else if (action.type === fullStateSyncActionType) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(		const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos,		entryInfos,
daysToEntries,		daysToEntries,
action.payload.rawEntryInfos,		action.payload.rawEntryInfos,
newThreadInfos,		newThreadInfos,
);		);
return [		return {
{		entryStore: {
entryInfos: updatedEntryInfos,		entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries,		daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar,		lastUserInteractionCalendar,
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (		} else if (
action.type === changeThreadSettingsActionTypes.success \|\|		action.type === changeThreadSettingsActionTypes.success \|\|
action.type === removeUsersFromThreadActionTypes.success \|\|		action.type === removeUsersFromThreadActionTypes.success \|\|
action.type === changeThreadMemberRolesActionTypes.success		action.type === changeThreadMemberRolesActionTypes.success
) {		) {
const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);		const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);
const newEntryInfos = _pickBy(		const newEntryInfos = _pickBy(
(entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],		(entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],
)(entryInfos);		)(entryInfos);
if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {		if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {
return [entryStore, []];		return {
		entryStore,
		entryStoreOperations: [],
		reportCreationRequests: [],
		};
}		}
const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(		const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(
daysToEntries,		daysToEntries,
newEntryInfos,		newEntryInfos,
);		);
return [		return {
{		entryStore: {
entryInfos: newEntryInfos,		entryInfos: newEntryInfos,
daysToEntries: newDaysToEntries,		daysToEntries: newDaysToEntries,
lastUserInteractionCalendar,		lastUserInteractionCalendar,
},		},
[],		entryStoreOperations: [],
];		reportCreationRequests: [],
		};
} else if (action.type === processServerRequestsActionType) {		} else if (action.type === processServerRequestsActionType) {
const checkStateRequest = action.payload.serverRequests.find(		const checkStateRequest = action.payload.serverRequests.find(
candidate => candidate.type === serverRequestTypes.CHECK_STATE,		candidate => candidate.type === serverRequestTypes.CHECK_STATE,
);		);
if (!checkStateRequest \|\| !checkStateRequest.stateChanges) {		if (!checkStateRequest \|\| !checkStateRequest.stateChanges) {
return [entryStore, []];		return {
		entryStore,
		entryStoreOperations: [],
		reportCreationRequests: [],
		};
}		}
const { rawEntryInfos, deleteEntryIDs } = checkStateRequest.stateChanges;		const { rawEntryInfos, deleteEntryIDs } = checkStateRequest.stateChanges;
if (!rawEntryInfos && !deleteEntryIDs) {		if (!rawEntryInfos && !deleteEntryIDs) {
return [entryStore, []];		return {
		entryStore,
		entryStoreOperations: [],
		reportCreationRequests: [],
		};
}		}

const updatedEntryInfos: { [string]: RawEntryInfo } = { ...entryInfos };		const updatedEntryInfos: { [string]: RawEntryInfo } = { ...entryInfos };
if (deleteEntryIDs) {		if (deleteEntryIDs) {
for (const deleteEntryID of deleteEntryIDs) {		for (const deleteEntryID of deleteEntryIDs) {
delete updatedEntryInfos[deleteEntryID];		delete updatedEntryInfos[deleteEntryID];
}		}
}		}
Show All 15 Lines	) {
}		}

const newInconsistencies = stateSyncSpecs.entries.findStoreInconsistencies(		const newInconsistencies = stateSyncSpecs.entries.findStoreInconsistencies(
action,		action,
entryInfos,		entryInfos,
mergedEntryInfos,		mergedEntryInfos,
);		);

return [		return {
{		entryStore: {
entryInfos: mergedEntryInfos,		entryInfos: mergedEntryInfos,
daysToEntries: mergedDaysToEntries,		daysToEntries: mergedDaysToEntries,
lastUserInteractionCalendar,		lastUserInteractionCalendar,
},		},
newInconsistencies,		entryStoreOperations: [],
];		reportCreationRequests: newInconsistencies,
		};
}		}
return [entryStore, []];		return {
		entryStore,
		entryStoreOperations: [],
		reportCreationRequests: [],
		};
}		}

function mergeUpdateEntryInfos(		function mergeUpdateEntryInfos(
entryInfos: $ReadOnlyArray<RawEntryInfo>,		entryInfos: $ReadOnlyArray<RawEntryInfo>,
newUpdates: $ReadOnlyArray<ClientUpdateInfo>,		newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
): RawEntryInfo[] {		): RawEntryInfo[] {
const entryIDs = new Set(		const entryIDs = new Set(
entryInfos.map(entryInfo => entryInfo.id).filter(Boolean),		entryInfos.map(entryInfo => entryInfo.id).filter(Boolean),
Show All 34 Lines

[lib] Use "your message" for reaction MessagePreviewClosedPublicActions