Paths

Table of Contentst

-
web/
-
components/
-
stepper.react.js
-
modals/threads/create/
-
threads/
-
create/
-
compose-subchannel-modal.react.js

Differential D10163

[web] Return dispatchCreateSubchannel directly in Stepper.Item nextProps
ClosedPublic
Actions

Authored by ashoat on Dec 4 2023, 1:10 PM.

Details

Reviewers

tomek

Commits

rCOMM37f8ead8e105: [web] Return dispatchCreateSubchannel directly in Stepper.Item nextProps

Summary

While working on the unused-promise Flow lint, I noticed that we can simplify this code if we adjust the API in the Stepper component to allow mixed instead of void returns.

Depends on D10162

Test Plan

Flow

Diff Detail

Repository

rCOMM Comm

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

ashoat created this revision.Dec 4 2023, 1:10 PM

ashoat added a child revision: D10164: [web] Don't handle promise for onDeviceTokenRegistered call in PushNotifsHandler.

Harbormaster completed remote builds in B24742: Diff 34205.Dec 4 2023, 2:28 PM

ashoat requested review of this revision.Dec 4 2023, 2:28 PM

tomek accepted this revision.Dec 5 2023, 5:07 AM

This revision is now accepted and ready to land.Dec 5 2023, 5:07 AM

Closed by commit rCOMM37f8ead8e105: [web] Return dispatchCreateSubchannel directly in Stepper.Item nextProps (authored by ashoat). · Explain WhyDec 5 2023, 12:32 PM

This revision was automatically updated to reflect the committed changes.

ashoat added a commit: rCOMM37f8ead8e105: [web] Return dispatchCreateSubchannel directly in Stepper.Item nextProps.

Revision Contents
Changeset List

Path

Size

web/

components/

stepper.react.js

2 lines

modals/

threads/

create/

compose-subchannel-modal.react.js

4 lines

Diff 34205

View Options

web/components/stepper.react.js

// @flow		// @flow

import invariant from 'invariant';		import invariant from 'invariant';
		import * as React from 'react';
		import uuid from 'uuid';

import genesis from '../facts/genesis.js';		import genesis from '../facts/genesis.js';
import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';		import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';		import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';		import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
		import {
		type OutboundDMOperationSpecification,
		dmOperationSpecificationTypes,
		} from '../shared/dm-ops/dm-op-utils.js';
		import { useProcessAndSendDMOperation } from '../shared/dm-ops/process-dm-ops.js';
import { permissionsAndAuthRelatedRequestTimeout } from '../shared/timeouts.js';		import { permissionsAndAuthRelatedRequestTimeout } from '../shared/timeouts.js';
import type {		import type {
		DMChangeThreadSettingsOperation,
		DMThreadSettingsChangesBase,
		} from '../types/dm-ops.js';
		import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
		import {
		thickThreadTypes,
		threadTypeIsThick,
		} from '../types/thread-types-enum.js';
		import type {
ChangeThreadSettingsPayload,		ChangeThreadSettingsPayload,
LeaveThreadPayload,		LeaveThreadPayload,
UpdateThreadRequest,		UpdateThreadRequest,
ClientNewThinThreadRequest,		ClientNewThinThreadRequest,
NewThreadResult,		NewThreadResult,
ClientThreadJoinRequest,		ClientThreadJoinRequest,
ThreadJoinPayload,		ThreadJoinPayload,
ThreadFetchMediaRequest,		ThreadFetchMediaRequest,
ThreadFetchMediaResult,		ThreadFetchMediaResult,
RoleModificationRequest,		RoleModificationRequest,
RoleModificationPayload,		RoleModificationPayload,
RoleDeletionRequest,		RoleDeletionRequest,
RoleDeletionPayload,		RoleDeletionPayload,
} from '../types/thread-types.js';		} from '../types/thread-types.js';
import { values } from '../utils/objects.js';		import { values } from '../utils/objects.js';
		import { useSelector } from '../utils/redux-utils.js';

export type DeleteThreadInput = {		export type DeleteThreadInput = {
+threadID: string,		+threadID: string,
};		};

const deleteThreadActionTypes = Object.freeze({		const deleteThreadActionTypes = Object.freeze({
started: 'DELETE_THREAD_STARTED',		started: 'DELETE_THREAD_STARTED',
success: 'DELETE_THREAD_SUCCESS',		success: 'DELETE_THREAD_SUCCESS',
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	async input => {
const response = responses[keyserverID];		const response = responses[keyserverID];
return {		return {
threadID: input.threadID,		threadID: input.threadID,
updatesResult: response.updatesResult,		updatesResult: response.updatesResult,
newMessageInfos: response.newMessageInfos,		newMessageInfos: response.newMessageInfos,
};		};
};		};

function useChangeThreadSettings(): (		function useChangeThreadSettings(
input: UpdateThreadRequest,		threadInfo: ?ThreadInfo,
) => Promise<ChangeThreadSettingsPayload> {		): (input: UpdateThreadRequest) => Promise<ChangeThreadSettingsPayload> {
return useKeyserverCall(changeThreadSettings);		const processAndSendDMOperation = useProcessAndSendDMOperation();
		const viewerID = useSelector(
		state => state.currentUserInfo && state.currentUserInfo.id,
		);

		const keyserverCall = useKeyserverCall(changeThreadSettings);

		return React.useCallback(
		async (input: UpdateThreadRequest) => {
		if (!threadInfo \|\| !threadTypeIsThick(threadInfo.type)) {
		return await keyserverCall(input);
		}

		invariant(viewerID, 'viewerID should be set');

		const changes: { ...DMThreadSettingsChangesBase } = {};
		if (input.changes.name) {
		changes.name = input.changes.name;
		}
		if (input.changes.description) {
		changes.description = input.changes.description;
		}
		if (input.changes.color) {
		changes.color = input.changes.color;
		}
		if (input.changes.avatar && input.changes.avatar.type === 'emoji') {
		changes.avatar = {
		type: 'emoji',
		emoji: input.changes.avatar.emoji,
		color: input.changes.avatar.color,
		};
		} else if (input.changes.avatar && input.changes.avatar.type === 'ens') {
		changes.avatar = { type: 'ens' };
		}
		// To support `image` and `encrypted_image` avatars we first, need stop
		// sending multimedia metadata to keyserver.
		// ENG-8708

		const op: DMChangeThreadSettingsOperation = {
		type: 'change_thread_settings',
		threadID: threadInfo.id,
		editorID: viewerID,
		time: Date.now(),
		changes,
		messageIDsPrefix: uuid.v4(),
		};
		const opSpecification: OutboundDMOperationSpecification = {
		type: dmOperationSpecificationTypes.OUTBOUND,
		op,
		recipients: {
		type: 'all_thread_members',
		threadID:
		threadInfo.type === thickThreadTypes.THICK_SIDEBAR &&
		threadInfo.parentThreadID
		? threadInfo.parentThreadID
		: threadInfo.id,
		},
		};

		await processAndSendDMOperation(opSpecification);
		return ({
		threadID: threadInfo.id,
		updatesResult: { newUpdates: [] },
		newMessageInfos: [],
		}: ChangeThreadSettingsPayload);
		},
		[keyserverCall, processAndSendDMOperation, threadInfo, viewerID],
		);
}		}

export type RemoveUsersFromThreadInput = {		export type RemoveUsersFromThreadInput = {
+threadID: string,		+threadID: string,
+memberIDs: $ReadOnlyArray<string>,		+memberIDs: $ReadOnlyArray<string>,
};		};

const removeUsersFromThreadActionTypes = Object.freeze({		const removeUsersFromThreadActionTypes = Object.freeze({
▲ Show 20 Lines • Show All 298 Lines • Show Last 20 Lines