Page MenuHomePhorge
Files F33438251

D13375.1769015879.diff
No OneTemporary
Actions

Size
6 KB
Referenced Files
None
Subscribers
None

D13375.1769015879.diff
View Options

diff --git a/lib/shared/dm-ops/dm-ops-queue-handler.react.js b/lib/shared/dm-ops/dm-ops-queue-handler.react.js
--- a/lib/shared/dm-ops/dm-ops-queue-handler.react.js
+++ b/lib/shared/dm-ops/dm-ops-queue-handler.react.js
@@ -1,11 +1,19 @@
// @flow
+import _mapValues from 'lodash/fp/mapValues.js';
import * as React from 'react';
import { dmOperationSpecificationTypes } from './dm-op-utils.js';
import { useProcessDMOperation } from './process-dm-ops.js';
-import { threadInfoSelector } from '../../selectors/thread-selectors.js';
+import { messageInfoSelector } from '../../selectors/chat-selectors.js';
import {
+ entryInfoSelector,
+ threadInfoSelector,
+} from '../../selectors/thread-selectors.js';
+import {
+ clearQueuedEntryDMOpsActionType,
+ clearQueuedMembershipDMOpsActionType,
+ clearQueuedMessageDMOpsActionType,
clearQueuedThreadDMOpsActionType,
pruneDMOpsQueueActionType,
} from '../../types/dm-ops.js';
@@ -45,7 +53,7 @@
);
const prevThreadIDsRef = React.useRef<$ReadOnlySet<string>>(new Set());
- const queuedOperations = useSelector(
+ const queuedThreadOperations = useSelector(
state => state.queuedDMOperations.threadQueue,
);
@@ -55,11 +63,11 @@
const prevThreadIDs = prevThreadIDsRef.current;
prevThreadIDsRef.current = threadIDs;
- for (const threadID in queuedOperations) {
+ for (const threadID in queuedThreadOperations) {
if (!threadIDs.has(threadID) || prevThreadIDs.has(threadID)) {
continue;
}
- for (const dmOp of queuedOperations[threadID]) {
+ for (const dmOp of queuedThreadOperations[threadID]) {
void processDMOperation({
// This is `INBOUND` because we assume that when generating
// `dmOperationSpecificationTypes.OUBOUND` it should be possible
@@ -79,7 +87,146 @@
},
});
}
- }, [dispatch, processDMOperation, queuedOperations, threadIDs]);
+ }, [dispatch, processDMOperation, queuedThreadOperations, threadIDs]);
+
+ const messageInfos = useSelector(messageInfoSelector);
+ const messageIDs = React.useMemo(
+ () => new Set(Object.keys(messageInfos)),
+ [messageInfos],
+ );
+ const prevMessageIDsRef = React.useRef<$ReadOnlySet<string>>(new Set());
+
+ const queuedMessageOperations = useSelector(
+ state => state.queuedDMOperations.messageQueue,
+ );
+
+ React.useEffect(() => {
+ const prevMessageIDs = prevMessageIDsRef.current;
+ prevMessageIDsRef.current = messageIDs;
+
+ for (const messageID in queuedMessageOperations) {
+ if (!messageIDs.has(messageID) || prevMessageIDs.has(messageID)) {
+ continue;
+ }
+
+ for (const dmOp of queuedMessageOperations[messageID]) {
+ void processDMOperation({
+ // This is `INBOUND` because we assume that when generating
+ // `dmOperationSpecificationTypes.OUBOUND` it should be possible
+ // to be processed and never queued up.
+ type: dmOperationSpecificationTypes.INBOUND,
+ op: dmOp.operation,
+ // There is no metadata, because messages were confirmed when
+ // adding to the queue.
+ metadata: null,
+ });
+ }
+
+ dispatch({
+ type: clearQueuedMessageDMOpsActionType,
+ payload: {
+ messageID,
+ },
+ });
+ }
+ }, [dispatch, messageIDs, processDMOperation, queuedMessageOperations]);
+
+ const entryInfos = useSelector(entryInfoSelector);
+ const entryIDs = React.useMemo(
+ () => new Set(Object.keys(entryInfos)),
+ [entryInfos],
+ );
+ const prevEntryIDsRef = React.useRef<$ReadOnlySet<string>>(new Set());
+
+ const queuedEntryOperations = useSelector(
+ state => state.queuedDMOperations.entryQueue,
+ );
+
+ React.useEffect(() => {
+ const prevEntryIDs = prevEntryIDsRef.current;
+ prevEntryIDsRef.current = entryIDs;
+
+ for (const entryID in queuedEntryOperations) {
+ if (!entryIDs.has(entryID) || prevEntryIDs.has(entryID)) {
+ continue;
+ }
+
+ for (const dmOp of queuedEntryOperations[entryID]) {
+ void processDMOperation({
+ // This is `INBOUND` because we assume that when generating
+ // `dmOperationSpecificationTypes.OUBOUND` it should be possible
+ // to be processed and never queued up.
+ type: dmOperationSpecificationTypes.INBOUND,
+ op: dmOp.operation,
+ // There is no metadata, because messages were confirmed when
+ // adding to the queue.
+ metadata: null,
+ });
+ }
+
+ dispatch({
+ type: clearQueuedEntryDMOpsActionType,
+ payload: {
+ entryID,
+ },
+ });
+ }
+ }, [dispatch, entryIDs, processDMOperation, queuedEntryOperations]);
+
+ const threadMembers = React.useMemo(
+ () =>
+ _mapValues(thread => new Set(thread.members.map(member => member.id)))(
+ threadInfos,
+ ),
+ [threadInfos],
+ );
+ const prevThreadMembersRef = React.useRef<{
+ +[threadID: string]: $ReadOnlySet<string>,
+ }>({});
+ const queuedMembershipOperations = useSelector(
+ state => state.queuedDMOperations.membershipQueue,
+ );
+
+ React.useEffect(() => {
+ const prevThreadMembers = prevThreadMembersRef.current;
+ prevThreadMembersRef.current = threadMembers;
+
+ for (const threadID in queuedMembershipOperations) {
+ if (!threadMembers[threadID]) {
+ continue;
+ }
+
+ for (const userID in queuedMembershipOperations[threadID]) {
+ if (
+ !threadMembers[threadID].has(userID) ||
+ prevThreadMembers[threadID]?.has(userID)
+ ) {
+ continue;
+ }
+
+ for (const dmOp of queuedMembershipOperations[threadID][userID] ?? {}) {
+ void processDMOperation({
+ // This is `INBOUND` because we assume that when generating
+ // `dmOperationSpecificationTypes.OUBOUND` it should be possible
+ // to be processed and never queued up.
+ type: dmOperationSpecificationTypes.INBOUND,
+ op: dmOp.operation,
+ // There is no metadata, because messages were confirmed when
+ // adding to the queue.
+ metadata: null,
+ });
+ }
+
+ dispatch({
+ type: clearQueuedMembershipDMOpsActionType,
+ payload: {
+ threadID,
+ userID,
+ },
+ });
+ }
+ }
+ }, [dispatch, processDMOperation, queuedMembershipOperations, threadMembers]);
return null;
}

File Metadata

Mime Type
text/plain
Expires
Wed, Jan 21, 5:17 PM (8 h, 40 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
5970259
Default Alt Text
D13375.1769015879.diff (6 KB)

Event Timeline