Page MenuHomePhabricator
Differential D3963

[native] [fix] [ENG-1099] fix hot reload compose component
ClosedPublic
Actions

Authored by • benschac on May 6 2022, 1:42 PM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Apr 8, 6:26 PM
Unknown Object (File)
Tue, Apr 8, 5:51 PM
Unknown Object (File)
Tue, Apr 8, 8:04 AM
Unknown Object (File)
Tue, Apr 8, 7:37 AM
Unknown Object (File)
Tue, Apr 8, 7:25 AM
Unknown Object (File)
Tue, Apr 8, 12:41 AM
Unknown Object (File)
Sat, Apr 5, 9:13 PM
Unknown Object (File)
Sat, Apr 5, 9:13 PM
View All Files
Subscribers
• adrian
ashoat

Details

Reviewers
atul
tomek
• jacek
• abosh
ashoat
Commits
rCOMM7a4b2a0a7264: [native] [fix] [ENG-1099] fix hot reload compose component
Summary

https://linear.app/comm/issue/ENG-1099/refactor-composed-message-component-to-fix-hot-reload

Test Plan

when editing compose component, it shouldn't move the developer back to inbox

Diff Detail

Repository
rCOMM Comm
Branch
inline-sidebar-web-and-native-ENG-530
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

• benschac created this revision.May 6 2022, 1:42 PM
Herald added subscribers: • adrian, ashoat. · View Herald TranscriptMay 6 2022, 1:42 PM
• benschac added inline comments.May 6 2022, 1:45 PM
native/chat/composed-message-constants.js
3

We don't have a set way/place to throw constants yet. Open to any suggestions. just made a new file for the moment. Having a constants file for chat would make sense in the long term.

• benschac added a parent revision: D3915: [web,native,lib] [refactor] [ENG-530] rename hook to useInlineEngagement from useInlineText.May 6 2022, 1:47 PM
Harbormaster completed remote builds in B8885: Diff 12388.May 6 2022, 1:47 PM
• benschac requested review of this revision.May 6 2022, 1:47 PM
ashoat accepted this revision.May 6 2022, 7:53 PM
ashoat added inline comments.
native/chat/composed-message.react.js
223

We should probably export default ConnectedComposedMessage since it's just the one component now

This revision is now accepted and ready to land.May 6 2022, 7:53 PM
• benschac updated this revision to Diff 12445.May 9 2022, 10:02 AM

address diff comment

native/chat/composed-message.react.js
223

makes sense

Harbormaster completed remote builds in B8936: Diff 12445.May 9 2022, 10:07 AM
Closed by commit rCOMM7a4b2a0a7264: [native] [fix] [ENG-1099] fix hot reload compose component (authored by • benschac). · Explain WhyMay 9 2022, 10:08 AM
This revision was automatically updated to reflect the committed changes.
• benschac added a commit: rCOMM7a4b2a0a7264: [native] [fix] [ENG-1099] fix hot reload compose component.

Revision Contents
Changeset List

Diff 12388

View Options

native/chat/composed-message-constants.js

// @flow // @flow
import _memoize from 'lodash/memoize.js';
import * as React from 'react'; import * as React from 'react';
import { useDispatch } from 'react-redux'; import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect';
import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js'; import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js';
import type { CallServerEndpointOptions } from './call-server-endpoint.js'; import type { BindServerCallsParams } from './action-utils.js';
import type { CallServerEndpointOptions } from './call-server-endpoint';
import { useSelector } from './redux-utils.js'; import { useSelector } from './redux-utils.js';
import type { PlatformDetails } from '../types/device-types.js';
import type { Endpoint } from '../types/endpoints.js'; import type { Endpoint } from '../types/endpoints.js';
import type { KeyserverInfo } from '../types/keyserver-types.js'; import type { KeyserverInfo } from '../types/keyserver-types.js';
import type { Dispatch } from '../types/redux-types.js'; import type { Dispatch } from '../types/redux-types.js';
import type { ConnectionStatus } from '../types/socket-types.js';
import type { CurrentUserInfo } from '../types/user-types.js'; import type { CurrentUserInfo } from '../types/user-types.js';
export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = ( export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = (
endpoint: Endpoint, endpoint: Endpoint,
input: any, input: any,
args: Args, args: Args,
options?: ?CallServerEndpointOptions, options?: ?CallServerEndpointOptions,
) => Promise<any>; ) => Promise<any>;
Show All 9 Lines | {
+keyserverIDExtractor: (...Args) => string, +keyserverIDExtractor: (...Args) => string,
}; };
export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = { export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = {
+actionFunc: ActionFunc<Args, Return>, +actionFunc: ActionFunc<Args, Return>,
+config: KeyserverCallConfig<Args>, +config: KeyserverCallConfig<Args>,
}; };
export type ExtractAndBindCookieAndUtilsParams< const boundCallServerEndpointSelector = createSelector(
Args: $ReadOnlyArray<mixed>, (state: BindServerCallsParams) => state.dispatch,
Return, (state: BindServerCallsParams) => state.cookie,
> = { (state: BindServerCallsParams) => state.urlPrefix,
(state: BindServerCallsParams) => state.sessionID,
(state: BindServerCallsParams) => state.currentUserInfo,
(state: BindServerCallsParams) => state.connectionStatus,
(state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,
(
dispatch: Dispatch,
cookie: ?string,
urlPrefix: string,
sessionID: ?string,
currentUserInfo: ?CurrentUserInfo,
connectionStatus: ConnectionStatus,
lastCommunicatedPlatformDetails: ?PlatformDetails,
) => {
return bindCookieAndUtilsIntoCallServerEndpoint({
dispatch,
cookie,
urlPrefix,
sessionID,
currentUserInfo,
connectionStatus,
lastCommunicatedPlatformDetails,
});
},
ashoatUnsubmitted
Not Done
Inline Actions
lastCommunicatedPlatformDetails: ?PlatformDetails,
- ) => {
- return bindCookieAndUtilsIntoCallServerEndpoint({
- dispatch,
- cookie,
- urlPrefix,
- sessionID,
- currentUserInfo,
- connectionStatus,
- lastCommunicatedPlatformDetails,
- });
- },
+ ) => bindCookieAndUtilsIntoCallServerEndpoint({
+ dispatch,
+ cookie,
+ urlPrefix,
+ sessionID,
+ currentUserInfo,
+ connectionStatus,
+ lastCommunicatedPlatformDetails,
+ }),
);
export type BindKeyserverCallParams = {

Nit: shorthand

ashoat: Nit: shorthand
);
export type BindKeyserverCallParams = {
+dispatch: Dispatch, +dispatch: Dispatch,
+currentUserInfo: ?CurrentUserInfo, +currentUserInfo: ?CurrentUserInfo,
+keyserverInfos: { +[keyserverID: string]: KeyserverInfo }, +keyserverInfos: { +[keyserverID: string]: KeyserverInfo },
+keyserverCall: KeyserverCall<Args, Return>,
}; };
function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>, Return>( export type GetCallKeyserverEndpointParams<Args: $ReadOnlyArray<mixed>> = {
params: ExtractAndBindCookieAndUtilsParams<Args, Return>, ...BindKeyserverCallParams,
): CallKeyserverEndpoint<Args> { +keyserverCallConfig: KeyserverCallConfig<Args>,
const { dispatch, keyserverInfos, currentUserInfo, keyserverCall } = params; };
const { config: serverCallConfig } = keyserverCall; function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>>(
params: GetCallKeyserverEndpointParams<Args>,
): CallKeyserverEndpoint<Args> {
const { dispatch, keyserverInfos, currentUserInfo, keyserverCallConfig } =
params;
return ( return (
endpoint: Endpoint, endpoint: Endpoint,
data: Object, data: Object,
args: Args, args: Args,
options?: ?CallServerEndpointOptions, options?: ?CallServerEndpointOptions,
) => { ) => {
// TODO // TODO
if (serverCallConfig.keyserverSelection === 'fanout') { if (keyserverCallConfig.keyserverSelection === 'fanout') {
return Promise.all([]); return Promise.all([]);
} }
const keyserverID = serverCallConfig.keyserverIDExtractor(...args); const keyserverID = keyserverCallConfig.keyserverIDExtractor(...args);
const { const {
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
connection, connection,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
} = keyserverInfos[keyserverID]; } = keyserverInfos[keyserverID];
const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({ const boundCallServerEndpoint = boundCallServerEndpointSelector({
dispatch, dispatch,
currentUserInfo, currentUserInfo,
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
connectionStatus: connection.status, connectionStatus: connection.status,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
}); });
return boundCallServerEndpoint(endpoint, data, options); return boundCallServerEndpoint(endpoint, data, options);
}; };
} }
const baseCreateBoundKeyserverCallActionSelector = <
Args: $ReadOnlyArray<mixed>,
Return,
>(
keyserverCall: KeyserverCall<Args, Return>,
): (BindKeyserverCallParams => (...Args) => Promise<Return>) =>
createSelector(
(state: BindKeyserverCallParams) => state.dispatch,
(state: BindKeyserverCallParams) => state.currentUserInfo,
(state: BindKeyserverCallParams) => state.keyserverInfos,
(
dispatch: Dispatch,
currentUserInfo: ?CurrentUserInfo,
keyserverInfos: { +[keyserverID: string]: KeyserverInfo },
) => {
const callKeyserverEndpoint = getCallKeyserverEndpoint({
dispatch,
currentUserInfo,
keyserverInfos,
keyserverCallConfig: keyserverCall.config,
});
return keyserverCall.actionFunc(callKeyserverEndpoint);
},
);
type CreateBoundKeyserverCallActionSelectorType = <
Args: $ReadOnlyArray<mixed>,
Return,
>(
keyserverCall: KeyserverCall<Args, Return>,
) => BindKeyserverCallParams => (...Args) => Promise<Return>;
const createBoundKeyserverCallActionSelector: CreateBoundKeyserverCallActionSelectorType =
_memoize(baseCreateBoundKeyserverCallActionSelector);
function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>( function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>(
keyserverCall: KeyserverCall<Args, Return>, keyserverCall: KeyserverCall<Args, Return>,
paramOverride?: ?$Shape<ExtractAndBindCookieAndUtilsParams<Args, Return>>, paramOverride?: ?$Shape<BindKeyserverCallParams>,
): (...Args) => Promise<Return> { ): (...Args) => Promise<Return> {
const dispatch = useDispatch(); const dispatch = useDispatch();
const keyserverInfos = useSelector( const keyserverInfos = useSelector(
state => state.keyserverStore.keyserverInfos, state => state.keyserverStore.keyserverInfos,
); );
const currentUserInfo = useSelector(state => state.currentUserInfo); const currentUserInfo = useSelector(state => state.currentUserInfo);
return React.useMemo(() => { return React.useMemo(
const callKeyserverEndpoint = getCallKeyserverEndpoint({ () =>
createBoundKeyserverCallActionSelector(keyserverCall)({
dispatch, dispatch,
currentUserInfo, currentUserInfo,
keyserverInfos, keyserverInfos,
keyserverCall,
...paramOverride, ...paramOverride,
}); }),
return keyserverCall.actionFunc(callKeyserverEndpoint);
}, [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride]); [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride],
);
} }
export { useKeyserverCall }; export { useKeyserverCall };
View Options

native/chat/composed-message.react.js

// @flow // @flow
import _memoize from 'lodash/memoize.js';
import * as React from 'react'; import * as React from 'react';
import { useDispatch } from 'react-redux'; import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect';
import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js'; import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js';
import type { CallServerEndpointOptions } from './call-server-endpoint.js'; import type { BindServerCallsParams } from './action-utils.js';
import type { CallServerEndpointOptions } from './call-server-endpoint';
import { useSelector } from './redux-utils.js'; import { useSelector } from './redux-utils.js';
import type { PlatformDetails } from '../types/device-types.js';
import type { Endpoint } from '../types/endpoints.js'; import type { Endpoint } from '../types/endpoints.js';
import type { KeyserverInfo } from '../types/keyserver-types.js'; import type { KeyserverInfo } from '../types/keyserver-types.js';
import type { Dispatch } from '../types/redux-types.js'; import type { Dispatch } from '../types/redux-types.js';
import type { ConnectionStatus } from '../types/socket-types.js';
import type { CurrentUserInfo } from '../types/user-types.js'; import type { CurrentUserInfo } from '../types/user-types.js';
export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = ( export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = (
endpoint: Endpoint, endpoint: Endpoint,
input: any, input: any,
args: Args, args: Args,
options?: ?CallServerEndpointOptions, options?: ?CallServerEndpointOptions,
) => Promise<any>; ) => Promise<any>;
Show All 9 Lines | {
+keyserverIDExtractor: (...Args) => string, +keyserverIDExtractor: (...Args) => string,
}; };
export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = { export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = {
+actionFunc: ActionFunc<Args, Return>, +actionFunc: ActionFunc<Args, Return>,
+config: KeyserverCallConfig<Args>, +config: KeyserverCallConfig<Args>,
}; };
export type ExtractAndBindCookieAndUtilsParams< const boundCallServerEndpointSelector = createSelector(
Args: $ReadOnlyArray<mixed>, (state: BindServerCallsParams) => state.dispatch,
Return, (state: BindServerCallsParams) => state.cookie,
> = { (state: BindServerCallsParams) => state.urlPrefix,
(state: BindServerCallsParams) => state.sessionID,
(state: BindServerCallsParams) => state.currentUserInfo,
(state: BindServerCallsParams) => state.connectionStatus,
(state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,
(
dispatch: Dispatch,
cookie: ?string,
urlPrefix: string,
sessionID: ?string,
currentUserInfo: ?CurrentUserInfo,
connectionStatus: ConnectionStatus,
lastCommunicatedPlatformDetails: ?PlatformDetails,
) => {
return bindCookieAndUtilsIntoCallServerEndpoint({
dispatch,
cookie,
urlPrefix,
sessionID,
currentUserInfo,
connectionStatus,
lastCommunicatedPlatformDetails,
});
},
ashoatUnsubmitted
Not Done
Inline Actions
lastCommunicatedPlatformDetails: ?PlatformDetails,
- ) => {
- return bindCookieAndUtilsIntoCallServerEndpoint({
- dispatch,
- cookie,
- urlPrefix,
- sessionID,
- currentUserInfo,
- connectionStatus,
- lastCommunicatedPlatformDetails,
- });
- },
+ ) => bindCookieAndUtilsIntoCallServerEndpoint({
+ dispatch,
+ cookie,
+ urlPrefix,
+ sessionID,
+ currentUserInfo,
+ connectionStatus,
+ lastCommunicatedPlatformDetails,
+ }),
);
export type BindKeyserverCallParams = {

Nit: shorthand

ashoat: Nit: shorthand
);
export type BindKeyserverCallParams = {
+dispatch: Dispatch, +dispatch: Dispatch,
+currentUserInfo: ?CurrentUserInfo, +currentUserInfo: ?CurrentUserInfo,
+keyserverInfos: { +[keyserverID: string]: KeyserverInfo }, +keyserverInfos: { +[keyserverID: string]: KeyserverInfo },
+keyserverCall: KeyserverCall<Args, Return>,
}; };
function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>, Return>( export type GetCallKeyserverEndpointParams<Args: $ReadOnlyArray<mixed>> = {
params: ExtractAndBindCookieAndUtilsParams<Args, Return>, ...BindKeyserverCallParams,
): CallKeyserverEndpoint<Args> { +keyserverCallConfig: KeyserverCallConfig<Args>,
const { dispatch, keyserverInfos, currentUserInfo, keyserverCall } = params; };
const { config: serverCallConfig } = keyserverCall; function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>>(
params: GetCallKeyserverEndpointParams<Args>,
): CallKeyserverEndpoint<Args> {
const { dispatch, keyserverInfos, currentUserInfo, keyserverCallConfig } =
params;
return ( return (
endpoint: Endpoint, endpoint: Endpoint,
data: Object, data: Object,
args: Args, args: Args,
options?: ?CallServerEndpointOptions, options?: ?CallServerEndpointOptions,
) => { ) => {
// TODO // TODO
if (serverCallConfig.keyserverSelection === 'fanout') { if (keyserverCallConfig.keyserverSelection === 'fanout') {
return Promise.all([]); return Promise.all([]);
} }
const keyserverID = serverCallConfig.keyserverIDExtractor(...args); const keyserverID = keyserverCallConfig.keyserverIDExtractor(...args);
const { const {
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
connection, connection,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
} = keyserverInfos[keyserverID]; } = keyserverInfos[keyserverID];
const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({ const boundCallServerEndpoint = boundCallServerEndpointSelector({
dispatch, dispatch,
currentUserInfo, currentUserInfo,
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
connectionStatus: connection.status, connectionStatus: connection.status,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
}); });
return boundCallServerEndpoint(endpoint, data, options); return boundCallServerEndpoint(endpoint, data, options);
}; };
} }
const baseCreateBoundKeyserverCallActionSelector = <
Args: $ReadOnlyArray<mixed>,
Return,
>(
keyserverCall: KeyserverCall<Args, Return>,
): (BindKeyserverCallParams => (...Args) => Promise<Return>) =>
createSelector(
(state: BindKeyserverCallParams) => state.dispatch,
(state: BindKeyserverCallParams) => state.currentUserInfo,
(state: BindKeyserverCallParams) => state.keyserverInfos,
(
dispatch: Dispatch,
currentUserInfo: ?CurrentUserInfo,
keyserverInfos: { +[keyserverID: string]: KeyserverInfo },
) => {
const callKeyserverEndpoint = getCallKeyserverEndpoint({
dispatch,
currentUserInfo,
keyserverInfos,
keyserverCallConfig: keyserverCall.config,
});
return keyserverCall.actionFunc(callKeyserverEndpoint);
},
);
type CreateBoundKeyserverCallActionSelectorType = <
Args: $ReadOnlyArray<mixed>,
Return,
>(
keyserverCall: KeyserverCall<Args, Return>,
) => BindKeyserverCallParams => (...Args) => Promise<Return>;
const createBoundKeyserverCallActionSelector: CreateBoundKeyserverCallActionSelectorType =
_memoize(baseCreateBoundKeyserverCallActionSelector);
function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>( function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>(
keyserverCall: KeyserverCall<Args, Return>, keyserverCall: KeyserverCall<Args, Return>,
paramOverride?: ?$Shape<ExtractAndBindCookieAndUtilsParams<Args, Return>>, paramOverride?: ?$Shape<BindKeyserverCallParams>,
): (...Args) => Promise<Return> { ): (...Args) => Promise<Return> {
const dispatch = useDispatch(); const dispatch = useDispatch();
const keyserverInfos = useSelector( const keyserverInfos = useSelector(
state => state.keyserverStore.keyserverInfos, state => state.keyserverStore.keyserverInfos,
); );
const currentUserInfo = useSelector(state => state.currentUserInfo); const currentUserInfo = useSelector(state => state.currentUserInfo);
return React.useMemo(() => { return React.useMemo(
const callKeyserverEndpoint = getCallKeyserverEndpoint({ () =>
createBoundKeyserverCallActionSelector(keyserverCall)({
dispatch, dispatch,
currentUserInfo, currentUserInfo,
keyserverInfos, keyserverInfos,
keyserverCall,
...paramOverride, ...paramOverride,
}); }),
return keyserverCall.actionFunc(callKeyserverEndpoint);
}, [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride]); [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride],
);
} }
export { useKeyserverCall }; export { useKeyserverCall };
View Options

native/chat/message-header.react.js

// @flow // @flow
import _memoize from 'lodash/memoize.js';
import * as React from 'react'; import * as React from 'react';
import { useDispatch } from 'react-redux'; import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect';
import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js'; import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js';
import type { CallServerEndpointOptions } from './call-server-endpoint.js'; import type { BindServerCallsParams } from './action-utils.js';
import type { CallServerEndpointOptions } from './call-server-endpoint';
import { useSelector } from './redux-utils.js'; import { useSelector } from './redux-utils.js';
import type { PlatformDetails } from '../types/device-types.js';
import type { Endpoint } from '../types/endpoints.js'; import type { Endpoint } from '../types/endpoints.js';
import type { KeyserverInfo } from '../types/keyserver-types.js'; import type { KeyserverInfo } from '../types/keyserver-types.js';
import type { Dispatch } from '../types/redux-types.js'; import type { Dispatch } from '../types/redux-types.js';
import type { ConnectionStatus } from '../types/socket-types.js';
import type { CurrentUserInfo } from '../types/user-types.js'; import type { CurrentUserInfo } from '../types/user-types.js';
export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = ( export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = (
endpoint: Endpoint, endpoint: Endpoint,
input: any, input: any,
args: Args, args: Args,
options?: ?CallServerEndpointOptions, options?: ?CallServerEndpointOptions,
) => Promise<any>; ) => Promise<any>;
Show All 9 Lines | {
+keyserverIDExtractor: (...Args) => string, +keyserverIDExtractor: (...Args) => string,
}; };
export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = { export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = {
+actionFunc: ActionFunc<Args, Return>, +actionFunc: ActionFunc<Args, Return>,
+config: KeyserverCallConfig<Args>, +config: KeyserverCallConfig<Args>,
}; };
export type ExtractAndBindCookieAndUtilsParams< const boundCallServerEndpointSelector = createSelector(
Args: $ReadOnlyArray<mixed>, (state: BindServerCallsParams) => state.dispatch,
Return, (state: BindServerCallsParams) => state.cookie,
> = { (state: BindServerCallsParams) => state.urlPrefix,
(state: BindServerCallsParams) => state.sessionID,
(state: BindServerCallsParams) => state.currentUserInfo,
(state: BindServerCallsParams) => state.connectionStatus,
(state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,
(
dispatch: Dispatch,
cookie: ?string,
urlPrefix: string,
sessionID: ?string,
currentUserInfo: ?CurrentUserInfo,
connectionStatus: ConnectionStatus,
lastCommunicatedPlatformDetails: ?PlatformDetails,
) => {
return bindCookieAndUtilsIntoCallServerEndpoint({
dispatch,
cookie,
urlPrefix,
sessionID,
currentUserInfo,
connectionStatus,
lastCommunicatedPlatformDetails,
});
},
ashoatUnsubmitted
Not Done
Inline Actions
lastCommunicatedPlatformDetails: ?PlatformDetails,
- ) => {
- return bindCookieAndUtilsIntoCallServerEndpoint({
- dispatch,
- cookie,
- urlPrefix,
- sessionID,
- currentUserInfo,
- connectionStatus,
- lastCommunicatedPlatformDetails,
- });
- },
+ ) => bindCookieAndUtilsIntoCallServerEndpoint({
+ dispatch,
+ cookie,
+ urlPrefix,
+ sessionID,
+ currentUserInfo,
+ connectionStatus,
+ lastCommunicatedPlatformDetails,
+ }),
);
export type BindKeyserverCallParams = {

Nit: shorthand

ashoat: Nit: shorthand
);
export type BindKeyserverCallParams = {
+dispatch: Dispatch, +dispatch: Dispatch,
+currentUserInfo: ?CurrentUserInfo, +currentUserInfo: ?CurrentUserInfo,
+keyserverInfos: { +[keyserverID: string]: KeyserverInfo }, +keyserverInfos: { +[keyserverID: string]: KeyserverInfo },
+keyserverCall: KeyserverCall<Args, Return>,
}; };
function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>, Return>( export type GetCallKeyserverEndpointParams<Args: $ReadOnlyArray<mixed>> = {
params: ExtractAndBindCookieAndUtilsParams<Args, Return>, ...BindKeyserverCallParams,
): CallKeyserverEndpoint<Args> { +keyserverCallConfig: KeyserverCallConfig<Args>,
const { dispatch, keyserverInfos, currentUserInfo, keyserverCall } = params; };
const { config: serverCallConfig } = keyserverCall; function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>>(
params: GetCallKeyserverEndpointParams<Args>,
): CallKeyserverEndpoint<Args> {
const { dispatch, keyserverInfos, currentUserInfo, keyserverCallConfig } =
params;
return ( return (
endpoint: Endpoint, endpoint: Endpoint,
data: Object, data: Object,
args: Args, args: Args,
options?: ?CallServerEndpointOptions, options?: ?CallServerEndpointOptions,
) => { ) => {
// TODO // TODO
if (serverCallConfig.keyserverSelection === 'fanout') { if (keyserverCallConfig.keyserverSelection === 'fanout') {
return Promise.all([]); return Promise.all([]);
} }
const keyserverID = serverCallConfig.keyserverIDExtractor(...args); const keyserverID = keyserverCallConfig.keyserverIDExtractor(...args);
const { const {
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
connection, connection,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
} = keyserverInfos[keyserverID]; } = keyserverInfos[keyserverID];
const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({ const boundCallServerEndpoint = boundCallServerEndpointSelector({
dispatch, dispatch,
currentUserInfo, currentUserInfo,
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
connectionStatus: connection.status, connectionStatus: connection.status,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
}); });
return boundCallServerEndpoint(endpoint, data, options); return boundCallServerEndpoint(endpoint, data, options);
}; };
} }
const baseCreateBoundKeyserverCallActionSelector = <
Args: $ReadOnlyArray<mixed>,
Return,
>(
keyserverCall: KeyserverCall<Args, Return>,
): (BindKeyserverCallParams => (...Args) => Promise<Return>) =>
createSelector(
(state: BindKeyserverCallParams) => state.dispatch,
(state: BindKeyserverCallParams) => state.currentUserInfo,
(state: BindKeyserverCallParams) => state.keyserverInfos,
(
dispatch: Dispatch,
currentUserInfo: ?CurrentUserInfo,
keyserverInfos: { +[keyserverID: string]: KeyserverInfo },
) => {
const callKeyserverEndpoint = getCallKeyserverEndpoint({
dispatch,
currentUserInfo,
keyserverInfos,
keyserverCallConfig: keyserverCall.config,
});
return keyserverCall.actionFunc(callKeyserverEndpoint);
},
);
type CreateBoundKeyserverCallActionSelectorType = <
Args: $ReadOnlyArray<mixed>,
Return,
>(
keyserverCall: KeyserverCall<Args, Return>,
) => BindKeyserverCallParams => (...Args) => Promise<Return>;
const createBoundKeyserverCallActionSelector: CreateBoundKeyserverCallActionSelectorType =
_memoize(baseCreateBoundKeyserverCallActionSelector);
function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>( function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>(
keyserverCall: KeyserverCall<Args, Return>, keyserverCall: KeyserverCall<Args, Return>,
paramOverride?: ?$Shape<ExtractAndBindCookieAndUtilsParams<Args, Return>>, paramOverride?: ?$Shape<BindKeyserverCallParams>,
): (...Args) => Promise<Return> { ): (...Args) => Promise<Return> {
const dispatch = useDispatch(); const dispatch = useDispatch();
const keyserverInfos = useSelector( const keyserverInfos = useSelector(
state => state.keyserverStore.keyserverInfos, state => state.keyserverStore.keyserverInfos,
); );
const currentUserInfo = useSelector(state => state.currentUserInfo); const currentUserInfo = useSelector(state => state.currentUserInfo);
return React.useMemo(() => { return React.useMemo(
const callKeyserverEndpoint = getCallKeyserverEndpoint({ () =>
createBoundKeyserverCallActionSelector(keyserverCall)({
dispatch, dispatch,
currentUserInfo, currentUserInfo,
keyserverInfos, keyserverInfos,
keyserverCall,
...paramOverride, ...paramOverride,
}); }),
return keyserverCall.actionFunc(callKeyserverEndpoint);
}, [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride]); [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride],
);
} }
export { useKeyserverCall }; export { useKeyserverCall };
View Options

native/chat/multimedia-message-utils.js

// @flow // @flow
import _memoize from 'lodash/memoize.js';
import * as React from 'react'; import * as React from 'react';
import { useDispatch } from 'react-redux'; import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect';
import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js'; import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js';
import type { CallServerEndpointOptions } from './call-server-endpoint.js'; import type { BindServerCallsParams } from './action-utils.js';
import type { CallServerEndpointOptions } from './call-server-endpoint';
import { useSelector } from './redux-utils.js'; import { useSelector } from './redux-utils.js';
import type { PlatformDetails } from '../types/device-types.js';
import type { Endpoint } from '../types/endpoints.js'; import type { Endpoint } from '../types/endpoints.js';
import type { KeyserverInfo } from '../types/keyserver-types.js'; import type { KeyserverInfo } from '../types/keyserver-types.js';
import type { Dispatch } from '../types/redux-types.js'; import type { Dispatch } from '../types/redux-types.js';
import type { ConnectionStatus } from '../types/socket-types.js';
import type { CurrentUserInfo } from '../types/user-types.js'; import type { CurrentUserInfo } from '../types/user-types.js';
export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = ( export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = (
endpoint: Endpoint, endpoint: Endpoint,
input: any, input: any,
args: Args, args: Args,
options?: ?CallServerEndpointOptions, options?: ?CallServerEndpointOptions,
) => Promise<any>; ) => Promise<any>;
Show All 9 Lines | {
+keyserverIDExtractor: (...Args) => string, +keyserverIDExtractor: (...Args) => string,
}; };
export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = { export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = {
+actionFunc: ActionFunc<Args, Return>, +actionFunc: ActionFunc<Args, Return>,
+config: KeyserverCallConfig<Args>, +config: KeyserverCallConfig<Args>,
}; };
export type ExtractAndBindCookieAndUtilsParams< const boundCallServerEndpointSelector = createSelector(
Args: $ReadOnlyArray<mixed>, (state: BindServerCallsParams) => state.dispatch,
Return, (state: BindServerCallsParams) => state.cookie,
> = { (state: BindServerCallsParams) => state.urlPrefix,
(state: BindServerCallsParams) => state.sessionID,
(state: BindServerCallsParams) => state.currentUserInfo,
(state: BindServerCallsParams) => state.connectionStatus,
(state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,
(
dispatch: Dispatch,
cookie: ?string,
urlPrefix: string,
sessionID: ?string,
currentUserInfo: ?CurrentUserInfo,
connectionStatus: ConnectionStatus,
lastCommunicatedPlatformDetails: ?PlatformDetails,
) => {
return bindCookieAndUtilsIntoCallServerEndpoint({
dispatch,
cookie,
urlPrefix,
sessionID,
currentUserInfo,
connectionStatus,
lastCommunicatedPlatformDetails,
});
},
ashoatUnsubmitted
Not Done
Inline Actions
lastCommunicatedPlatformDetails: ?PlatformDetails,
- ) => {
- return bindCookieAndUtilsIntoCallServerEndpoint({
- dispatch,
- cookie,
- urlPrefix,
- sessionID,
- currentUserInfo,
- connectionStatus,
- lastCommunicatedPlatformDetails,
- });
- },
+ ) => bindCookieAndUtilsIntoCallServerEndpoint({
+ dispatch,
+ cookie,
+ urlPrefix,
+ sessionID,
+ currentUserInfo,
+ connectionStatus,
+ lastCommunicatedPlatformDetails,
+ }),
);
export type BindKeyserverCallParams = {

Nit: shorthand

ashoat: Nit: shorthand
);
export type BindKeyserverCallParams = {
+dispatch: Dispatch, +dispatch: Dispatch,
+currentUserInfo: ?CurrentUserInfo, +currentUserInfo: ?CurrentUserInfo,
+keyserverInfos: { +[keyserverID: string]: KeyserverInfo }, +keyserverInfos: { +[keyserverID: string]: KeyserverInfo },
+keyserverCall: KeyserverCall<Args, Return>,
}; };
function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>, Return>( export type GetCallKeyserverEndpointParams<Args: $ReadOnlyArray<mixed>> = {
params: ExtractAndBindCookieAndUtilsParams<Args, Return>, ...BindKeyserverCallParams,
): CallKeyserverEndpoint<Args> { +keyserverCallConfig: KeyserverCallConfig<Args>,
const { dispatch, keyserverInfos, currentUserInfo, keyserverCall } = params; };
const { config: serverCallConfig } = keyserverCall; function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>>(
params: GetCallKeyserverEndpointParams<Args>,
): CallKeyserverEndpoint<Args> {
const { dispatch, keyserverInfos, currentUserInfo, keyserverCallConfig } =
params;
return ( return (
endpoint: Endpoint, endpoint: Endpoint,
data: Object, data: Object,
args: Args, args: Args,
options?: ?CallServerEndpointOptions, options?: ?CallServerEndpointOptions,
) => { ) => {
// TODO // TODO
if (serverCallConfig.keyserverSelection === 'fanout') { if (keyserverCallConfig.keyserverSelection === 'fanout') {
return Promise.all([]); return Promise.all([]);
} }
const keyserverID = serverCallConfig.keyserverIDExtractor(...args); const keyserverID = keyserverCallConfig.keyserverIDExtractor(...args);
const { const {
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
connection, connection,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
} = keyserverInfos[keyserverID]; } = keyserverInfos[keyserverID];
const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({ const boundCallServerEndpoint = boundCallServerEndpointSelector({
dispatch, dispatch,
currentUserInfo, currentUserInfo,
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
connectionStatus: connection.status, connectionStatus: connection.status,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
}); });
return boundCallServerEndpoint(endpoint, data, options); return boundCallServerEndpoint(endpoint, data, options);
}; };
} }
const baseCreateBoundKeyserverCallActionSelector = <
Args: $ReadOnlyArray<mixed>,
Return,
>(
keyserverCall: KeyserverCall<Args, Return>,
): (BindKeyserverCallParams => (...Args) => Promise<Return>) =>
createSelector(
(state: BindKeyserverCallParams) => state.dispatch,
(state: BindKeyserverCallParams) => state.currentUserInfo,
(state: BindKeyserverCallParams) => state.keyserverInfos,
(
dispatch: Dispatch,
currentUserInfo: ?CurrentUserInfo,
keyserverInfos: { +[keyserverID: string]: KeyserverInfo },
) => {
const callKeyserverEndpoint = getCallKeyserverEndpoint({
dispatch,
currentUserInfo,
keyserverInfos,
keyserverCallConfig: keyserverCall.config,
});
return keyserverCall.actionFunc(callKeyserverEndpoint);
},
);
type CreateBoundKeyserverCallActionSelectorType = <
Args: $ReadOnlyArray<mixed>,
Return,
>(
keyserverCall: KeyserverCall<Args, Return>,
) => BindKeyserverCallParams => (...Args) => Promise<Return>;
const createBoundKeyserverCallActionSelector: CreateBoundKeyserverCallActionSelectorType =
_memoize(baseCreateBoundKeyserverCallActionSelector);
function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>( function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>(
keyserverCall: KeyserverCall<Args, Return>, keyserverCall: KeyserverCall<Args, Return>,
paramOverride?: ?$Shape<ExtractAndBindCookieAndUtilsParams<Args, Return>>, paramOverride?: ?$Shape<BindKeyserverCallParams>,
): (...Args) => Promise<Return> { ): (...Args) => Promise<Return> {
const dispatch = useDispatch(); const dispatch = useDispatch();
const keyserverInfos = useSelector( const keyserverInfos = useSelector(
state => state.keyserverStore.keyserverInfos, state => state.keyserverStore.keyserverInfos,
); );
const currentUserInfo = useSelector(state => state.currentUserInfo); const currentUserInfo = useSelector(state => state.currentUserInfo);
return React.useMemo(() => { return React.useMemo(
const callKeyserverEndpoint = getCallKeyserverEndpoint({ () =>
createBoundKeyserverCallActionSelector(keyserverCall)({
dispatch, dispatch,
currentUserInfo, currentUserInfo,
keyserverInfos, keyserverInfos,
keyserverCall,
...paramOverride, ...paramOverride,
}); }),
return keyserverCall.actionFunc(callKeyserverEndpoint);
}, [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride]); [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride],
);
} }
export { useKeyserverCall }; export { useKeyserverCall };
View Options

native/chat/utils.js

// @flow // @flow
import _memoize from 'lodash/memoize.js';
import * as React from 'react'; import * as React from 'react';
import { useDispatch } from 'react-redux'; import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect';
import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js'; import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js';
import type { CallServerEndpointOptions } from './call-server-endpoint.js'; import type { BindServerCallsParams } from './action-utils.js';
import type { CallServerEndpointOptions } from './call-server-endpoint';
import { useSelector } from './redux-utils.js'; import { useSelector } from './redux-utils.js';
import type { PlatformDetails } from '../types/device-types.js';
import type { Endpoint } from '../types/endpoints.js'; import type { Endpoint } from '../types/endpoints.js';
import type { KeyserverInfo } from '../types/keyserver-types.js'; import type { KeyserverInfo } from '../types/keyserver-types.js';
import type { Dispatch } from '../types/redux-types.js'; import type { Dispatch } from '../types/redux-types.js';
import type { ConnectionStatus } from '../types/socket-types.js';
import type { CurrentUserInfo } from '../types/user-types.js'; import type { CurrentUserInfo } from '../types/user-types.js';
export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = ( export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = (
endpoint: Endpoint, endpoint: Endpoint,
input: any, input: any,
args: Args, args: Args,
options?: ?CallServerEndpointOptions, options?: ?CallServerEndpointOptions,
) => Promise<any>; ) => Promise<any>;
Show All 9 Lines | {
+keyserverIDExtractor: (...Args) => string, +keyserverIDExtractor: (...Args) => string,
}; };
export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = { export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = {
+actionFunc: ActionFunc<Args, Return>, +actionFunc: ActionFunc<Args, Return>,
+config: KeyserverCallConfig<Args>, +config: KeyserverCallConfig<Args>,
}; };
export type ExtractAndBindCookieAndUtilsParams< const boundCallServerEndpointSelector = createSelector(
Args: $ReadOnlyArray<mixed>, (state: BindServerCallsParams) => state.dispatch,
Return, (state: BindServerCallsParams) => state.cookie,
> = { (state: BindServerCallsParams) => state.urlPrefix,
(state: BindServerCallsParams) => state.sessionID,
(state: BindServerCallsParams) => state.currentUserInfo,
(state: BindServerCallsParams) => state.connectionStatus,
(state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,
(
dispatch: Dispatch,
cookie: ?string,
urlPrefix: string,
sessionID: ?string,
currentUserInfo: ?CurrentUserInfo,
connectionStatus: ConnectionStatus,
lastCommunicatedPlatformDetails: ?PlatformDetails,
) => {
return bindCookieAndUtilsIntoCallServerEndpoint({
dispatch,
cookie,
urlPrefix,
sessionID,
currentUserInfo,
connectionStatus,
lastCommunicatedPlatformDetails,
});
},
ashoatUnsubmitted
Not Done
Inline Actions
lastCommunicatedPlatformDetails: ?PlatformDetails,
- ) => {
- return bindCookieAndUtilsIntoCallServerEndpoint({
- dispatch,
- cookie,
- urlPrefix,
- sessionID,
- currentUserInfo,
- connectionStatus,
- lastCommunicatedPlatformDetails,
- });
- },
+ ) => bindCookieAndUtilsIntoCallServerEndpoint({
+ dispatch,
+ cookie,
+ urlPrefix,
+ sessionID,
+ currentUserInfo,
+ connectionStatus,
+ lastCommunicatedPlatformDetails,
+ }),
);
export type BindKeyserverCallParams = {

Nit: shorthand

ashoat: Nit: shorthand
);
export type BindKeyserverCallParams = {
+dispatch: Dispatch, +dispatch: Dispatch,
+currentUserInfo: ?CurrentUserInfo, +currentUserInfo: ?CurrentUserInfo,
+keyserverInfos: { +[keyserverID: string]: KeyserverInfo }, +keyserverInfos: { +[keyserverID: string]: KeyserverInfo },
+keyserverCall: KeyserverCall<Args, Return>,
}; };
function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>, Return>( export type GetCallKeyserverEndpointParams<Args: $ReadOnlyArray<mixed>> = {
params: ExtractAndBindCookieAndUtilsParams<Args, Return>, ...BindKeyserverCallParams,
): CallKeyserverEndpoint<Args> { +keyserverCallConfig: KeyserverCallConfig<Args>,
const { dispatch, keyserverInfos, currentUserInfo, keyserverCall } = params; };
const { config: serverCallConfig } = keyserverCall; function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>>(
params: GetCallKeyserverEndpointParams<Args>,
): CallKeyserverEndpoint<Args> {
const { dispatch, keyserverInfos, currentUserInfo, keyserverCallConfig } =
params;
return ( return (
endpoint: Endpoint, endpoint: Endpoint,
data: Object, data: Object,
args: Args, args: Args,
options?: ?CallServerEndpointOptions, options?: ?CallServerEndpointOptions,
) => { ) => {
// TODO // TODO
if (serverCallConfig.keyserverSelection === 'fanout') { if (keyserverCallConfig.keyserverSelection === 'fanout') {
return Promise.all([]); return Promise.all([]);
} }
const keyserverID = serverCallConfig.keyserverIDExtractor(...args); const keyserverID = keyserverCallConfig.keyserverIDExtractor(...args);
const { const {
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
connection, connection,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
} = keyserverInfos[keyserverID]; } = keyserverInfos[keyserverID];
const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({ const boundCallServerEndpoint = boundCallServerEndpointSelector({
dispatch, dispatch,
currentUserInfo, currentUserInfo,
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
connectionStatus: connection.status, connectionStatus: connection.status,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
}); });
return boundCallServerEndpoint(endpoint, data, options); return boundCallServerEndpoint(endpoint, data, options);
}; };
} }
const baseCreateBoundKeyserverCallActionSelector = <
Args: $ReadOnlyArray<mixed>,
Return,
>(
keyserverCall: KeyserverCall<Args, Return>,
): (BindKeyserverCallParams => (...Args) => Promise<Return>) =>
createSelector(
(state: BindKeyserverCallParams) => state.dispatch,
(state: BindKeyserverCallParams) => state.currentUserInfo,
(state: BindKeyserverCallParams) => state.keyserverInfos,
(
dispatch: Dispatch,
currentUserInfo: ?CurrentUserInfo,
keyserverInfos: { +[keyserverID: string]: KeyserverInfo },
) => {
const callKeyserverEndpoint = getCallKeyserverEndpoint({
dispatch,
currentUserInfo,
keyserverInfos,
keyserverCallConfig: keyserverCall.config,
});
return keyserverCall.actionFunc(callKeyserverEndpoint);
},
);
type CreateBoundKeyserverCallActionSelectorType = <
Args: $ReadOnlyArray<mixed>,
Return,
>(
keyserverCall: KeyserverCall<Args, Return>,
) => BindKeyserverCallParams => (...Args) => Promise<Return>;
const createBoundKeyserverCallActionSelector: CreateBoundKeyserverCallActionSelectorType =
_memoize(baseCreateBoundKeyserverCallActionSelector);
function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>( function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>(
keyserverCall: KeyserverCall<Args, Return>, keyserverCall: KeyserverCall<Args, Return>,
paramOverride?: ?$Shape<ExtractAndBindCookieAndUtilsParams<Args, Return>>, paramOverride?: ?$Shape<BindKeyserverCallParams>,
): (...Args) => Promise<Return> { ): (...Args) => Promise<Return> {
const dispatch = useDispatch(); const dispatch = useDispatch();
const keyserverInfos = useSelector( const keyserverInfos = useSelector(
state => state.keyserverStore.keyserverInfos, state => state.keyserverStore.keyserverInfos,
); );
const currentUserInfo = useSelector(state => state.currentUserInfo); const currentUserInfo = useSelector(state => state.currentUserInfo);
return React.useMemo(() => { return React.useMemo(
const callKeyserverEndpoint = getCallKeyserverEndpoint({ () =>
createBoundKeyserverCallActionSelector(keyserverCall)({
dispatch, dispatch,
currentUserInfo, currentUserInfo,
keyserverInfos, keyserverInfos,
keyserverCall,
...paramOverride, ...paramOverride,
}); }),
return keyserverCall.actionFunc(callKeyserverEndpoint);
}, [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride]); [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride],
);
} }
export { useKeyserverCall }; export { useKeyserverCall };