Page MenuHomePhabricator
Differential D10827

[native] new AlertDetails
ClosedPublic
Actions

Authored by varun on Jan 25 2024, 3:33 PM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Apr 9, 12:28 AM
Unknown Object (File)
Thu, Mar 13, 11:03 AM
Unknown Object (File)
Feb 26 2025, 6:18 PM
Unknown Object (File)
Feb 22 2025, 11:01 AM
Unknown Object (File)
Feb 22 2025, 11:01 AM
Unknown Object (File)
Feb 22 2025, 11:01 AM
Unknown Object (File)
Feb 22 2025, 11:01 AM
Unknown Object (File)
Feb 12 2025, 6:39 PM
View All 68 Files
Subscribers
tomek

Details

Reviewers
ashoat
Commits
rCOMM115ef992a8bc: [native] new AlertDetails
Summary

didn't want to duplicate code further

Depends on D10821

Test Plan

flow

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

Diff 36832

View Options

native/account/fullscreen-siwe-panel.react.js

// @flow // @flow
import { getConfig } from './config.js';
import { olmSessionErrors } from './olm-utils.js';
import { type AuthMetadata } from '../shared/identity-client-context.js';
import type { TunnelbrokerClientMessageToDevice } from '../tunnelbroker/tunnelbroker-context.js';
import {
outboundP2PMessageStatuses,
type OutboundP2PMessage,
} from '../types/sqlite-types.js';
import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
function getClientMessageIDFromTunnelbrokerMessageID( function getClientMessageIDFromTunnelbrokerMessageID(
tunnelbrokerMessageID: string, tunnelbrokerMessageID: string,
): string { ): string {
const ids = tunnelbrokerMessageID.split('#'); const ids = tunnelbrokerMessageID.split('#');
if (ids.length !== 2) { if (ids.length !== 2) {
throw new Error('Invalid tunnelbrokerMessageID'); throw new Error('Invalid tunnelbrokerMessageID');
} }
return ids[1]; return ids[1];
} }
export { getClientMessageIDFromTunnelbrokerMessageID }; async function sendMessageToPeer(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<'success' | 'failure'> {
const { sqliteAPI } = getConfig();
if (!authMetadata || !authMetadata.deviceID || !authMetadata.userID) {
return 'failure';
}
try {
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: {
deviceID: authMetadata.deviceID,
userID: authMetadata.userID,
},
encryptedData: JSON.parse(message.ciphertext),
};
await sendMessage(
{
deviceID: message.deviceID,
payload: JSON.stringify(encryptedMessage),
},
message.messageID,
);
await sqliteAPI.markOutboundP2PMessageAsSent(
message.messageID,
message.deviceID,
);
return 'success';
} catch (e) {
console.error(e);
return 'failure';
}
}
async function encryptAndSendMessageToPeer(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<'success' | 'failure' | 'missing_session'> {
const { olmAPI } = getConfig();
try {
const result = await olmAPI.encryptAndPersist(
message.plaintext,
message.deviceID,
message.messageID,
);
const encryptedMessage: OutboundP2PMessage = {
...message,
ciphertext: JSON.stringify(result),
};
return await sendMessageToPeer(encryptedMessage, authMetadata, sendMessage);
} catch (e) {
if (e.message?.includes(olmSessionErrors.sessionDoesNotExist)) {
return 'missing_session';
}
console.log(`Error sending messages to peer ${message.deviceID}`, e);
return 'failure';
}
}
export type HandleOutboundP2PMessageResult = {
+status: 'success' | 'failure' | 'missing_session',
+messageID: string,
};
async function handleOutboundP2PMessage(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<HandleOutboundP2PMessageResult> {
if (message.status === outboundP2PMessageStatuses.persisted) {
const status = await encryptAndSendMessageToPeer(
message,
authMetadata,
sendMessage,
);
return {
status,
messageID: message.messageID,
};
} else if (message.status === outboundP2PMessageStatuses.encrypted) {
const status = await sendMessageToPeer(message, authMetadata, sendMessage);
return {
status,
messageID: message.messageID,
};
} else if (message.status === outboundP2PMessageStatuses.sent) {
// Handle edge-case when message was sent, but it wasn't updated
// in the message store.
return {
status: 'success',
messageID: message.messageID,
};
}
return {
status: 'failure',
messageID: message.messageID,
};
}
export type EphemeralEncryptAndSendMessageToPeerResult = {
+status: 'success' | 'failure' | 'missing_session',
+recipient: { +userID: string, +deviceID: string },
};
async function ephemeralEncryptAndSendMessageToPeer(
contentPayload: string,
recipient: { +userID: string, +deviceID: string },
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<EphemeralEncryptAndSendMessageToPeerResult> {
const { olmAPI } = getConfig();
if (!authMetadata || !authMetadata.deviceID || !authMetadata.userID) {
return { status: 'failure', recipient };
}
const senderInfo = {
deviceID: authMetadata.deviceID,
userID: authMetadata.userID,
};
try {
const encryptedData = await olmAPI.encrypt(
contentPayload,
recipient.deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo,
encryptedData,
};
await sendMessage({
deviceID: recipient.deviceID,
payload: JSON.stringify(encryptedMessage),
});
return { status: 'success', recipient };
} catch (e) {
if (e.message?.includes(olmSessionErrors.sessionDoesNotExist)) {
return { status: 'missing_session', recipient };
}
console.log(`Error sending messages to peer ${recipient.deviceID}`, e);
return { status: 'failure', recipient };
}
}
export {
getClientMessageIDFromTunnelbrokerMessageID,
sendMessageToPeer,
encryptAndSendMessageToPeer,
ephemeralEncryptAndSendMessageToPeer,
handleOutboundP2PMessage,
};
View Options

native/account/log-in-panel.react.js

// @flow // @flow
import { getConfig } from './config.js';
import { olmSessionErrors } from './olm-utils.js';
import { type AuthMetadata } from '../shared/identity-client-context.js';
import type { TunnelbrokerClientMessageToDevice } from '../tunnelbroker/tunnelbroker-context.js';
import {
outboundP2PMessageStatuses,
type OutboundP2PMessage,
} from '../types/sqlite-types.js';
import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
function getClientMessageIDFromTunnelbrokerMessageID( function getClientMessageIDFromTunnelbrokerMessageID(
tunnelbrokerMessageID: string, tunnelbrokerMessageID: string,
): string { ): string {
const ids = tunnelbrokerMessageID.split('#'); const ids = tunnelbrokerMessageID.split('#');
if (ids.length !== 2) { if (ids.length !== 2) {
throw new Error('Invalid tunnelbrokerMessageID'); throw new Error('Invalid tunnelbrokerMessageID');
} }
return ids[1]; return ids[1];
} }
export { getClientMessageIDFromTunnelbrokerMessageID }; async function sendMessageToPeer(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<'success' | 'failure'> {
const { sqliteAPI } = getConfig();
if (!authMetadata || !authMetadata.deviceID || !authMetadata.userID) {
return 'failure';
}
try {
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: {
deviceID: authMetadata.deviceID,
userID: authMetadata.userID,
},
encryptedData: JSON.parse(message.ciphertext),
};
await sendMessage(
{
deviceID: message.deviceID,
payload: JSON.stringify(encryptedMessage),
},
message.messageID,
);
await sqliteAPI.markOutboundP2PMessageAsSent(
message.messageID,
message.deviceID,
);
return 'success';
} catch (e) {
console.error(e);
return 'failure';
}
}
async function encryptAndSendMessageToPeer(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<'success' | 'failure' | 'missing_session'> {
const { olmAPI } = getConfig();
try {
const result = await olmAPI.encryptAndPersist(
message.plaintext,
message.deviceID,
message.messageID,
);
const encryptedMessage: OutboundP2PMessage = {
...message,
ciphertext: JSON.stringify(result),
};
return await sendMessageToPeer(encryptedMessage, authMetadata, sendMessage);
} catch (e) {
if (e.message?.includes(olmSessionErrors.sessionDoesNotExist)) {
return 'missing_session';
}
console.log(`Error sending messages to peer ${message.deviceID}`, e);
return 'failure';
}
}
export type HandleOutboundP2PMessageResult = {
+status: 'success' | 'failure' | 'missing_session',
+messageID: string,
};
async function handleOutboundP2PMessage(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<HandleOutboundP2PMessageResult> {
if (message.status === outboundP2PMessageStatuses.persisted) {
const status = await encryptAndSendMessageToPeer(
message,
authMetadata,
sendMessage,
);
return {
status,
messageID: message.messageID,
};
} else if (message.status === outboundP2PMessageStatuses.encrypted) {
const status = await sendMessageToPeer(message, authMetadata, sendMessage);
return {
status,
messageID: message.messageID,
};
} else if (message.status === outboundP2PMessageStatuses.sent) {
// Handle edge-case when message was sent, but it wasn't updated
// in the message store.
return {
status: 'success',
messageID: message.messageID,
};
}
return {
status: 'failure',
messageID: message.messageID,
};
}
export type EphemeralEncryptAndSendMessageToPeerResult = {
+status: 'success' | 'failure' | 'missing_session',
+recipient: { +userID: string, +deviceID: string },
};
async function ephemeralEncryptAndSendMessageToPeer(
contentPayload: string,
recipient: { +userID: string, +deviceID: string },
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<EphemeralEncryptAndSendMessageToPeerResult> {
const { olmAPI } = getConfig();
if (!authMetadata || !authMetadata.deviceID || !authMetadata.userID) {
return { status: 'failure', recipient };
}
const senderInfo = {
deviceID: authMetadata.deviceID,
userID: authMetadata.userID,
};
try {
const encryptedData = await olmAPI.encrypt(
contentPayload,
recipient.deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo,
encryptedData,
};
await sendMessage({
deviceID: recipient.deviceID,
payload: JSON.stringify(encryptedMessage),
});
return { status: 'success', recipient };
} catch (e) {
if (e.message?.includes(olmSessionErrors.sessionDoesNotExist)) {
return { status: 'missing_session', recipient };
}
console.log(`Error sending messages to peer ${recipient.deviceID}`, e);
return { status: 'failure', recipient };
}
}
export {
getClientMessageIDFromTunnelbrokerMessageID,
sendMessageToPeer,
encryptAndSendMessageToPeer,
ephemeralEncryptAndSendMessageToPeer,
handleOutboundP2PMessage,
};
View Options

native/account/register-panel.react.js

// @flow // @flow
import { getConfig } from './config.js';
import { olmSessionErrors } from './olm-utils.js';
import { type AuthMetadata } from '../shared/identity-client-context.js';
import type { TunnelbrokerClientMessageToDevice } from '../tunnelbroker/tunnelbroker-context.js';
import {
outboundP2PMessageStatuses,
type OutboundP2PMessage,
} from '../types/sqlite-types.js';
import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
function getClientMessageIDFromTunnelbrokerMessageID( function getClientMessageIDFromTunnelbrokerMessageID(
tunnelbrokerMessageID: string, tunnelbrokerMessageID: string,
): string { ): string {
const ids = tunnelbrokerMessageID.split('#'); const ids = tunnelbrokerMessageID.split('#');
if (ids.length !== 2) { if (ids.length !== 2) {
throw new Error('Invalid tunnelbrokerMessageID'); throw new Error('Invalid tunnelbrokerMessageID');
} }
return ids[1]; return ids[1];
} }
export { getClientMessageIDFromTunnelbrokerMessageID }; async function sendMessageToPeer(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<'success' | 'failure'> {
const { sqliteAPI } = getConfig();
if (!authMetadata || !authMetadata.deviceID || !authMetadata.userID) {
return 'failure';
}
try {
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: {
deviceID: authMetadata.deviceID,
userID: authMetadata.userID,
},
encryptedData: JSON.parse(message.ciphertext),
};
await sendMessage(
{
deviceID: message.deviceID,
payload: JSON.stringify(encryptedMessage),
},
message.messageID,
);
await sqliteAPI.markOutboundP2PMessageAsSent(
message.messageID,
message.deviceID,
);
return 'success';
} catch (e) {
console.error(e);
return 'failure';
}
}
async function encryptAndSendMessageToPeer(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<'success' | 'failure' | 'missing_session'> {
const { olmAPI } = getConfig();
try {
const result = await olmAPI.encryptAndPersist(
message.plaintext,
message.deviceID,
message.messageID,
);
const encryptedMessage: OutboundP2PMessage = {
...message,
ciphertext: JSON.stringify(result),
};
return await sendMessageToPeer(encryptedMessage, authMetadata, sendMessage);
} catch (e) {
if (e.message?.includes(olmSessionErrors.sessionDoesNotExist)) {
return 'missing_session';
}
console.log(`Error sending messages to peer ${message.deviceID}`, e);
return 'failure';
}
}
export type HandleOutboundP2PMessageResult = {
+status: 'success' | 'failure' | 'missing_session',
+messageID: string,
};
async function handleOutboundP2PMessage(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<HandleOutboundP2PMessageResult> {
if (message.status === outboundP2PMessageStatuses.persisted) {
const status = await encryptAndSendMessageToPeer(
message,
authMetadata,
sendMessage,
);
return {
status,
messageID: message.messageID,
};
} else if (message.status === outboundP2PMessageStatuses.encrypted) {
const status = await sendMessageToPeer(message, authMetadata, sendMessage);
return {
status,
messageID: message.messageID,
};
} else if (message.status === outboundP2PMessageStatuses.sent) {
// Handle edge-case when message was sent, but it wasn't updated
// in the message store.
return {
status: 'success',
messageID: message.messageID,
};
}
return {
status: 'failure',
messageID: message.messageID,
};
}
export type EphemeralEncryptAndSendMessageToPeerResult = {
+status: 'success' | 'failure' | 'missing_session',
+recipient: { +userID: string, +deviceID: string },
};
async function ephemeralEncryptAndSendMessageToPeer(
contentPayload: string,
recipient: { +userID: string, +deviceID: string },
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<EphemeralEncryptAndSendMessageToPeerResult> {
const { olmAPI } = getConfig();
if (!authMetadata || !authMetadata.deviceID || !authMetadata.userID) {
return { status: 'failure', recipient };
}
const senderInfo = {
deviceID: authMetadata.deviceID,
userID: authMetadata.userID,
};
try {
const encryptedData = await olmAPI.encrypt(
contentPayload,
recipient.deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo,
encryptedData,
};
await sendMessage({
deviceID: recipient.deviceID,
payload: JSON.stringify(encryptedMessage),
});
return { status: 'success', recipient };
} catch (e) {
if (e.message?.includes(olmSessionErrors.sessionDoesNotExist)) {
return { status: 'missing_session', recipient };
}
console.log(`Error sending messages to peer ${recipient.deviceID}`, e);
return { status: 'failure', recipient };
}
}
export {
getClientMessageIDFromTunnelbrokerMessageID,
sendMessageToPeer,
encryptAndSendMessageToPeer,
ephemeralEncryptAndSendMessageToPeer,
handleOutboundP2PMessage,
};
View Options

native/account/registration/existing-ethereum-account.react.js

// @flow // @flow
import { getConfig } from './config.js';
import { olmSessionErrors } from './olm-utils.js';
import { type AuthMetadata } from '../shared/identity-client-context.js';
import type { TunnelbrokerClientMessageToDevice } from '../tunnelbroker/tunnelbroker-context.js';
import {
outboundP2PMessageStatuses,
type OutboundP2PMessage,
} from '../types/sqlite-types.js';
import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
function getClientMessageIDFromTunnelbrokerMessageID( function getClientMessageIDFromTunnelbrokerMessageID(
tunnelbrokerMessageID: string, tunnelbrokerMessageID: string,
): string { ): string {
const ids = tunnelbrokerMessageID.split('#'); const ids = tunnelbrokerMessageID.split('#');
if (ids.length !== 2) { if (ids.length !== 2) {
throw new Error('Invalid tunnelbrokerMessageID'); throw new Error('Invalid tunnelbrokerMessageID');
} }
return ids[1]; return ids[1];
} }
export { getClientMessageIDFromTunnelbrokerMessageID }; async function sendMessageToPeer(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<'success' | 'failure'> {
const { sqliteAPI } = getConfig();
if (!authMetadata || !authMetadata.deviceID || !authMetadata.userID) {
return 'failure';
}
try {
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: {
deviceID: authMetadata.deviceID,
userID: authMetadata.userID,
},
encryptedData: JSON.parse(message.ciphertext),
};
await sendMessage(
{
deviceID: message.deviceID,
payload: JSON.stringify(encryptedMessage),
},
message.messageID,
);
await sqliteAPI.markOutboundP2PMessageAsSent(
message.messageID,
message.deviceID,
);
return 'success';
} catch (e) {
console.error(e);
return 'failure';
}
}
async function encryptAndSendMessageToPeer(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<'success' | 'failure' | 'missing_session'> {
const { olmAPI } = getConfig();
try {
const result = await olmAPI.encryptAndPersist(
message.plaintext,
message.deviceID,
message.messageID,
);
const encryptedMessage: OutboundP2PMessage = {
...message,
ciphertext: JSON.stringify(result),
};
return await sendMessageToPeer(encryptedMessage, authMetadata, sendMessage);
} catch (e) {
if (e.message?.includes(olmSessionErrors.sessionDoesNotExist)) {
return 'missing_session';
}
console.log(`Error sending messages to peer ${message.deviceID}`, e);
return 'failure';
}
}
export type HandleOutboundP2PMessageResult = {
+status: 'success' | 'failure' | 'missing_session',
+messageID: string,
};
async function handleOutboundP2PMessage(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<HandleOutboundP2PMessageResult> {
if (message.status === outboundP2PMessageStatuses.persisted) {
const status = await encryptAndSendMessageToPeer(
message,
authMetadata,
sendMessage,
);
return {
status,
messageID: message.messageID,
};
} else if (message.status === outboundP2PMessageStatuses.encrypted) {
const status = await sendMessageToPeer(message, authMetadata, sendMessage);
return {
status,
messageID: message.messageID,
};
} else if (message.status === outboundP2PMessageStatuses.sent) {
// Handle edge-case when message was sent, but it wasn't updated
// in the message store.
return {
status: 'success',
messageID: message.messageID,
};
}
return {
status: 'failure',
messageID: message.messageID,
};
}
export type EphemeralEncryptAndSendMessageToPeerResult = {
+status: 'success' | 'failure' | 'missing_session',
+recipient: { +userID: string, +deviceID: string },
};
async function ephemeralEncryptAndSendMessageToPeer(
contentPayload: string,
recipient: { +userID: string, +deviceID: string },
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<EphemeralEncryptAndSendMessageToPeerResult> {
const { olmAPI } = getConfig();
if (!authMetadata || !authMetadata.deviceID || !authMetadata.userID) {
return { status: 'failure', recipient };
}
const senderInfo = {
deviceID: authMetadata.deviceID,
userID: authMetadata.userID,
};
try {
const encryptedData = await olmAPI.encrypt(
contentPayload,
recipient.deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo,
encryptedData,
};
await sendMessage({
deviceID: recipient.deviceID,
payload: JSON.stringify(encryptedMessage),
});
return { status: 'success', recipient };
} catch (e) {
if (e.message?.includes(olmSessionErrors.sessionDoesNotExist)) {
return { status: 'missing_session', recipient };
}
console.log(`Error sending messages to peer ${recipient.deviceID}`, e);
return { status: 'failure', recipient };
}
}
export {
getClientMessageIDFromTunnelbrokerMessageID,
sendMessageToPeer,
encryptAndSendMessageToPeer,
ephemeralEncryptAndSendMessageToPeer,
handleOutboundP2PMessage,
};
View Options

native/account/registration/registration-server-call.js

Loading...
View Options

native/account/siwe-panel.react.js

Loading...
View Options

native/chat/compose-subchannel.react.js

Loading...
View Options

native/chat/relationship-prompt.react.js

Loading...
View Options

native/chat/settings/add-users-modal.react.js

Loading...
View Options

native/chat/settings/color-selector-modal.react.js

Loading...
View Options

native/chat/settings/delete-thread.react.js

Loading...
View Options

native/chat/settings/thread-settings-description.react.js

Loading...
View Options

native/chat/settings/thread-settings-edit-relationship.react.js

Loading...
View Options

native/chat/settings/thread-settings-leave-thread.react.js

Loading...
View Options

native/chat/settings/thread-settings-name.react.js

Loading...
View Options

native/chat/settings/thread-settings-promote-sidebar.react.js

Loading...
View Options

native/profile/default-notifications-preferences.react.js

Loading...
View Options

native/profile/edit-password.react.js

Loading...
View Options

native/profile/relationship-list-item.react.js

Loading...
View Options

native/profile/relationship-list.react.js

Loading...
View Options

native/profile/user-relationship-tooltip-modal.react.js

Loading...
View Options

native/user-profile/user-profile-relationship-button.react.js

Loading...
View Options

native/utils/alert-messages.js

Loading...