diff --git a/keyserver/src/responders/website-responders.js b/keyserver/src/responders/website-responders.js
index 8b23e2162..a0c9fa41b 100644
--- a/keyserver/src/responders/website-responders.js
+++ b/keyserver/src/responders/website-responders.js
@@ -1,635 +1,734 @@
// @flow
import html from 'common-tags/lib/html/index.js';
import { detect as detectBrowser } from 'detect-browser';
import type { $Response, $Request } from 'express';
import fs from 'fs';
+import _isEqual from 'lodash/fp/isEqual.js';
import _keyBy from 'lodash/fp/keyBy.js';
import * as React from 'react';
// eslint-disable-next-line import/extensions
import ReactDOMServer from 'react-dom/server';
+import t from 'tcomb';
import { promisify } from 'util';
import { baseLegalPolicies } from 'lib/facts/policies.js';
import stores from 'lib/facts/stores.js';
import { daysToEntriesFromEntryInfos } from 'lib/reducers/entry-reducer.js';
import { freshMessageStore } from 'lib/reducers/message-reducer.js';
import { mostRecentlyReadThread } from 'lib/selectors/thread-selectors.js';
import { mostRecentMessageTimestamp } from 'lib/shared/message-utils.js';
import {
threadHasPermission,
threadIsPending,
parsePendingThreadID,
createPendingThread,
} from 'lib/shared/thread-utils.js';
import { defaultWebEnabledApps } from 'lib/types/enabled-apps.js';
+import { entryStoreValidator } from 'lib/types/entry-types.js';
import { defaultCalendarFilters } from 'lib/types/filter-types.js';
-import { defaultNumberPerThread } from 'lib/types/message-types.js';
+import {
+ defaultNumberPerThread,
+ messageStoreValidator,
+} from 'lib/types/message-types.js';
import { defaultEnabledReports } from 'lib/types/report-types.js';
import { defaultConnectionInfo } from 'lib/types/socket-types.js';
import { threadPermissions } from 'lib/types/thread-permission-types.js';
import { threadTypes } from 'lib/types/thread-types-enum.js';
+import { threadStoreValidator } from 'lib/types/thread-types.js';
+import {
+ currentUserInfoValidator,
+ userInfosValidator,
+} from 'lib/types/user-types.js';
import { currentDateInTimeZone } from 'lib/utils/date-utils.js';
import { ServerError } from 'lib/utils/errors.js';
import { promiseAll } from 'lib/utils/promises.js';
import { defaultNotifPermissionAlertInfo } from 'lib/utils/push-alerts.js';
+import { tBool, tNumber, tShape, tString } from 'lib/utils/validation-utils.js';
import getTitle from 'web/title/getTitle.js';
+import { navInfoValidator } from 'web/types/nav-types.js';
import { navInfoFromURL } from 'web/url-utils.js';
import { fetchEntryInfos } from '../fetchers/entry-fetchers.js';
import { fetchMessageInfos } from '../fetchers/message-fetchers.js';
import { hasAnyNotAcknowledgedPolicies } from '../fetchers/policy-acknowledgment-fetchers.js';
import { fetchThreadInfos } from '../fetchers/thread-fetchers.js';
import {
fetchCurrentUserInfo,
fetchKnownUserInfos,
} from '../fetchers/user-fetchers.js';
import { getWebPushConfig } from '../push/providers.js';
import { setNewSession } from '../session/cookies.js';
import { Viewer } from '../session/viewer.js';
import { streamJSON, waitForStream } from '../utils/json-stream.js';
import { getAppURLFactsFromRequestURL } from '../utils/urls.js';
+import { validateOutput } from '../utils/validation-utils.js';
const { renderToNodeStream } = ReactDOMServer;
const access = promisify(fs.access);
const readFile = promisify(fs.readFile);
const googleFontsURL =
'https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@400;500;600&family=Inter:wght@400;500;600&display=swap';
const localFontsURL = 'fonts/local-fonts.css';
async function getFontsURL() {
try {
await access(localFontsURL);
return localFontsURL;
} catch {
return googleFontsURL;
}
}
type AssetInfo = {
+jsURL: string,
+fontsURL: string,
+cssInclude: string,
+olmFilename: string,
+sqljsFilename: string,
+opaqueURL: string,
};
let assetInfo: ?AssetInfo = null;
async function getAssetInfo() {
if (assetInfo) {
return assetInfo;
}
if (process.env.NODE_ENV === 'development') {
const fontsURL = await getFontsURL();
assetInfo = {
jsURL: 'http://localhost:8080/dev.build.js',
fontsURL,
cssInclude: '',
olmFilename: '',
sqljsFilename: '',
opaqueURL: 'http://localhost:8080/opaque-ke.wasm',
};
return assetInfo;
}
try {
const manifestString = await readFile('../web/dist/manifest.json', 'utf8');
const manifest = JSON.parse(manifestString);
const webworkersManifestString = await readFile(
'../web/dist/webworkers/manifest.json',
'utf8',
);
const webworkersManifest = JSON.parse(webworkersManifestString);
assetInfo = {
jsURL: `compiled/${manifest['browser.js']}`,
fontsURL: googleFontsURL,
cssInclude: html`
`,
olmFilename: manifest['olm.wasm'],
sqljsFilename: webworkersManifest['sql-wasm.wasm'],
opaqueURL: `compiled/${manifest['comm_opaque2_wasm_bg.wasm']}`,
};
return assetInfo;
} catch {
throw new Error(
'Could not load manifest.json for web build. ' +
'Did you forget to run `yarn dev` in the web folder?',
);
}
}
let webpackCompiledRootComponent: ?React.ComponentType<{}> = null;
async function getWebpackCompiledRootComponentForSSR() {
if (webpackCompiledRootComponent) {
return webpackCompiledRootComponent;
}
try {
// $FlowFixMe web/dist doesn't always exist
const webpackBuild = await import('web/dist/app.build.cjs');
webpackCompiledRootComponent = webpackBuild.app.default;
return webpackCompiledRootComponent;
} catch {
throw new Error(
'Could not load app.build.cjs. ' +
'Did you forget to run `yarn dev` in the web folder?',
);
}
}
+const initialReduxStateValidator = tShape({
+ navInfo: navInfoValidator,
+ deviceID: t.Nil,
+ currentUserInfo: currentUserInfoValidator,
+ draftStore: t.irreducible('default draftStore', _isEqual({ drafts: {} })),
+ sessionID: t.maybe(t.String),
+ entryStore: entryStoreValidator,
+ threadStore: threadStoreValidator,
+ userStore: tShape({
+ userInfos: userInfosValidator,
+ inconsistencyReports: t.irreducible(
+ 'default inconsistencyReports',
+ _isEqual([]),
+ ),
+ }),
+ messageStore: messageStoreValidator,
+ updatesCurrentAsOf: t.Number,
+ loadingStatuses: t.irreducible('default loadingStatuses', _isEqual({})),
+ calendarFilters: t.irreducible(
+ 'defaultCalendarFilters',
+ _isEqual(defaultCalendarFilters),
+ ),
+ urlPrefix: tString(''),
+ windowDimensions: t.irreducible(
+ 'default windowDimensions',
+ _isEqual({ width: 0, height: 0 }),
+ ),
+ baseHref: t.String,
+ notifPermissionAlertInfo: t.irreducible(
+ 'default notifPermissionAlertInfo',
+ _isEqual(defaultNotifPermissionAlertInfo),
+ ),
+ connection: tShape({
+ status: tString('connecting'),
+ queuedActivityUpdates: t.irreducible(
+ 'default queuedActivityUpdates',
+ _isEqual([]),
+ ),
+ actualizedCalendarQuery: tShape({
+ startDate: t.String,
+ endDate: t.String,
+ filters: t.irreducible(
+ 'default filters',
+ _isEqual(defaultCalendarFilters),
+ ),
+ }),
+ lateResponses: t.irreducible('default lateResponses', _isEqual([])),
+ showDisconnectedBar: tBool(false),
+ }),
+ watchedThreadIDs: t.irreducible('default watchedThreadIDs', _isEqual([])),
+ lifecycleState: tString('active'),
+ enabledApps: t.irreducible(
+ 'defaultWebEnabledApps',
+ _isEqual(defaultWebEnabledApps),
+ ),
+ reportStore: t.irreducible(
+ 'default reportStore',
+ _isEqual({
+ enabledReports: defaultEnabledReports,
+ queuedReports: [],
+ }),
+ ),
+ nextLocalID: tNumber(0),
+ cookie: t.Nil,
+ deviceToken: t.Nil,
+ dataLoaded: t.Boolean,
+ windowActive: tBool(true),
+ userPolicies: t.irreducible('default userPolicies', _isEqual({})),
+ cryptoStore: t.irreducible(
+ 'default cryptoStore',
+ _isEqual({
+ primaryIdentityKeys: null,
+ notificationIdentityKeys: null,
+ }),
+ ),
+ pushApiPublicKey: t.maybe(t.String),
+ _persist: t.Nil,
+ commServicesAccessToken: t.Nil,
+});
+
async function websiteResponder(
viewer: Viewer,
req: $Request,
res: $Response,
): Promise {
const appURLFacts = getAppURLFactsFromRequestURL(req.originalUrl);
const { basePath, baseDomain } = appURLFacts;
const baseURL = basePath.replace(/\/$/, '');
const baseHref = baseDomain + baseURL;
const loadingPromise = getWebpackCompiledRootComponentForSSR();
const hasNotAcknowledgedPoliciesPromise = hasAnyNotAcknowledgedPolicies(
viewer.id,
baseLegalPolicies,
);
let initialNavInfo;
try {
initialNavInfo = navInfoFromURL(req.url, {
now: currentDateInTimeZone(viewer.timeZone),
});
} catch (e) {
throw new ServerError(e.message);
}
const calendarQuery = {
startDate: initialNavInfo.startDate,
endDate: initialNavInfo.endDate,
filters: defaultCalendarFilters,
};
const messageSelectionCriteria = { joinedThreads: true };
const initialTime = Date.now();
const assetInfoPromise = getAssetInfo();
const threadInfoPromise = fetchThreadInfos(viewer);
const messageInfoPromise = fetchMessageInfos(
viewer,
messageSelectionCriteria,
defaultNumberPerThread,
);
const entryInfoPromise = fetchEntryInfos(viewer, [calendarQuery]);
const currentUserInfoPromise = fetchCurrentUserInfo(viewer);
const userInfoPromise = fetchKnownUserInfos(viewer);
const sessionIDPromise = (async () => {
if (viewer.loggedIn) {
await setNewSession(viewer, calendarQuery, initialTime);
}
return viewer.sessionID;
})();
const threadStorePromise = (async () => {
const [{ threadInfos }, hasNotAcknowledgedPolicies] = await Promise.all([
threadInfoPromise,
hasNotAcknowledgedPoliciesPromise,
]);
return { threadInfos: hasNotAcknowledgedPolicies ? {} : threadInfos };
})();
const messageStorePromise = (async () => {
const [
{ threadInfos },
{ rawMessageInfos, truncationStatuses },
hasNotAcknowledgedPolicies,
] = await Promise.all([
threadInfoPromise,
messageInfoPromise,
hasNotAcknowledgedPoliciesPromise,
]);
if (hasNotAcknowledgedPolicies) {
return {
messages: {},
threads: {},
local: {},
currentAsOf: 0,
};
}
const { messageStore: freshStore } = freshMessageStore(
rawMessageInfos,
truncationStatuses,
mostRecentMessageTimestamp(rawMessageInfos, initialTime),
threadInfos,
);
return freshStore;
})();
const entryStorePromise = (async () => {
const [{ rawEntryInfos }, hasNotAcknowledgedPolicies] = await Promise.all([
entryInfoPromise,
hasNotAcknowledgedPoliciesPromise,
]);
if (hasNotAcknowledgedPolicies) {
return {
entryInfos: {},
daysToEntries: {},
lastUserInteractionCalendar: 0,
};
}
return {
entryInfos: _keyBy('id')(rawEntryInfos),
daysToEntries: daysToEntriesFromEntryInfos(rawEntryInfos),
lastUserInteractionCalendar: initialTime,
};
})();
const userStorePromise = (async () => {
const [userInfos, hasNotAcknowledgedPolicies] = await Promise.all([
userInfoPromise,
hasNotAcknowledgedPoliciesPromise,
]);
return {
userInfos: hasNotAcknowledgedPolicies ? {} : userInfos,
inconsistencyReports: [],
};
})();
const navInfoPromise = (async () => {
const [{ threadInfos }, messageStore, currentUserInfo, userStore] =
await Promise.all([
threadInfoPromise,
messageStorePromise,
currentUserInfoPromise,
userStorePromise,
]);
const finalNavInfo = initialNavInfo;
const requestedActiveChatThreadID = finalNavInfo.activeChatThreadID;
if (
requestedActiveChatThreadID &&
!threadIsPending(requestedActiveChatThreadID) &&
!threadHasPermission(
threadInfos[requestedActiveChatThreadID],
threadPermissions.VISIBLE,
)
) {
finalNavInfo.activeChatThreadID = null;
}
if (!finalNavInfo.activeChatThreadID) {
const mostRecentThread = mostRecentlyReadThread(
messageStore,
threadInfos,
);
if (mostRecentThread) {
finalNavInfo.activeChatThreadID = mostRecentThread;
}
}
if (
finalNavInfo.activeChatThreadID &&
threadIsPending(finalNavInfo.activeChatThreadID) &&
finalNavInfo.pendingThread?.id !== finalNavInfo.activeChatThreadID
) {
const pendingThreadData = parsePendingThreadID(
finalNavInfo.activeChatThreadID,
);
if (
pendingThreadData &&
pendingThreadData.threadType !== threadTypes.SIDEBAR &&
currentUserInfo.id
) {
const { userInfos } = userStore;
const members = [...pendingThreadData.memberIDs, currentUserInfo.id]
.map(id => {
const userInfo = userInfos[id];
if (!userInfo || !userInfo.username) {
return undefined;
}
const { username } = userInfo;
return { id, username };
})
.filter(Boolean);
const newPendingThread = createPendingThread({
viewerID: currentUserInfo.id,
threadType: pendingThreadData.threadType,
members,
});
finalNavInfo.activeChatThreadID = newPendingThread.id;
finalNavInfo.pendingThread = newPendingThread;
}
}
return finalNavInfo;
})();
const currentAsOfPromise = (async () => {
const hasNotAcknowledgedPolicies = await hasNotAcknowledgedPoliciesPromise;
return hasNotAcknowledgedPolicies ? 0 : initialTime;
})();
const pushApiPublicKeyPromise = (async () => {
const pushConfig = await getWebPushConfig();
if (!pushConfig) {
if (process.env.NODE_ENV !== 'development') {
console.warn('keyserver/secrets/web_push_config.json should exist');
}
return null;
}
return pushConfig.publicKey;
})();
const { jsURL, fontsURL, cssInclude, olmFilename, sqljsFilename, opaqueURL } =
await assetInfoPromise;
// prettier-ignore
res.write(html`
${getTitle(0)}
${cssInclude}
`);
const Loading = await loadingPromise;
const reactStream = renderToNodeStream();
reactStream.pipe(res, { end: false });
await waitForStream(reactStream);
res.write(html`
`);
}
const inviteSecretRegex = /^[a-z0-9]+$/i;
async function inviteResponder(req: $Request, res: $Response): Promise {
const { secret } = req.params;
const userAgent = req.get('User-Agent');
const detectionResult = detectBrowser(userAgent);
if (detectionResult.os === 'Android OS') {
const isSecretValid = inviteSecretRegex.test(secret);
const referrer = isSecretValid
? `&referrer=${encodeURIComponent(`utm_source=invite/${secret}`)}`
: '';
const redirectUrl = `${stores.googlePlayUrl}${referrer}`;
res.writeHead(301, {
Location: redirectUrl,
});
res.end();
return;
}
const fontsURL = await getFontsURL();
res.end(html`
Comm
To join this community, download the Comm app and reopen this invite
link
Visit Comm’s website
`);
}
export { websiteResponder, inviteResponder };
diff --git a/lib/types/entry-types.js b/lib/types/entry-types.js
index c10a7ea43..e9a1cd5cd 100644
--- a/lib/types/entry-types.js
+++ b/lib/types/entry-types.js
@@ -1,230 +1,235 @@
// @flow
import t, { type TInterface } from 'tcomb';
import { type Platform, isWebPlatform } from './device-types.js';
import { type CalendarFilter, defaultCalendarFilters } from './filter-types.js';
import type { RawMessageInfo } from './message-types.js';
import type {
ServerCreateUpdatesResponse,
ClientCreateUpdatesResponse,
} from './update-types.js';
import type { UserInfo, AccountUserInfo } from './user-types.js';
import {
fifteenDaysEarlier,
fifteenDaysLater,
thisMonthDates,
} from '../utils/date-utils.js';
import { tID, tShape } from '../utils/validation-utils.js';
export type RawEntryInfo = {
id?: string, // null if local copy without ID yet
localID?: string, // for optimistic creations
threadID: string,
text: string,
year: number,
month: number, // 1-indexed
day: number, // 1-indexed
creationTime: number, // millisecond timestamp
creatorID: string,
deleted: boolean,
};
export const rawEntryInfoValidator: TInterface =
tShape({
id: t.maybe(tID),
localID: t.maybe(t.String),
threadID: tID,
text: t.String,
year: t.Number,
month: t.Number,
day: t.Number,
creationTime: t.Number,
creatorID: t.String,
deleted: t.Boolean,
});
export type EntryInfo = {
id?: string, // null if local copy without ID yet
localID?: string, // for optimistic creations
threadID: string,
text: string,
year: number,
month: number, // 1-indexed
day: number, // 1-indexed
creationTime: number, // millisecond timestamp
creator: ?UserInfo,
deleted: boolean,
};
export type EntryStore = {
+entryInfos: { +[id: string]: RawEntryInfo },
+daysToEntries: { +[day: string]: string[] },
+lastUserInteractionCalendar: number,
};
+export const entryStoreValidator: TInterface = tShape({
+ entryInfos: t.dict(tID, rawEntryInfoValidator),
+ daysToEntries: t.dict(t.String, t.list(tID)),
+ lastUserInteractionCalendar: t.Number,
+});
export type CalendarQuery = {
+startDate: string,
+endDate: string,
+filters: $ReadOnlyArray,
};
export const defaultCalendarQuery = (
platform: ?Platform,
timeZone?: ?string,
): CalendarQuery => {
if (isWebPlatform(platform)) {
return {
...thisMonthDates(timeZone),
filters: defaultCalendarFilters,
};
} else {
return {
startDate: fifteenDaysEarlier(timeZone).valueOf(),
endDate: fifteenDaysLater(timeZone).valueOf(),
filters: defaultCalendarFilters,
};
}
};
export type SaveEntryInfo = {
+entryID: string,
+text: string,
+prevText: string,
+timestamp: number,
+calendarQuery: CalendarQuery,
};
export type SaveEntryRequest = {
+entryID: string,
+sessionID?: empty,
+text: string,
+prevText: string,
+timestamp: number,
+calendarQuery?: CalendarQuery,
};
export type SaveEntryResponse = {
+entryID: string,
+newMessageInfos: $ReadOnlyArray,
+updatesResult: ServerCreateUpdatesResponse,
};
export type SaveEntryResult = {
+entryID: string,
+newMessageInfos: $ReadOnlyArray,
+updatesResult: ClientCreateUpdatesResponse,
};
export type SaveEntryPayload = {
...SaveEntryResult,
+threadID: string,
};
export type CreateEntryInfo = {
+text: string,
+timestamp: number,
+date: string,
+threadID: string,
+localID: string,
+calendarQuery: CalendarQuery,
};
export type CreateEntryRequest = {
+text: string,
+sessionID?: empty,
+timestamp: number,
+date: string,
+threadID: string,
+localID?: string,
+calendarQuery?: CalendarQuery,
};
export type CreateEntryPayload = {
...SaveEntryPayload,
+localID: string,
};
export type DeleteEntryInfo = {
+entryID: string,
+prevText: string,
+calendarQuery: CalendarQuery,
};
export type DeleteEntryRequest = {
+entryID: string,
+sessionID?: empty,
+prevText: string,
+timestamp: number,
+calendarQuery?: CalendarQuery,
};
export type RestoreEntryInfo = {
+entryID: string,
+calendarQuery: CalendarQuery,
};
export type RestoreEntryRequest = {
+entryID: string,
+sessionID?: empty,
+timestamp: number,
+calendarQuery?: CalendarQuery,
};
export type DeleteEntryResponse = {
+newMessageInfos: $ReadOnlyArray,
+threadID: string,
+updatesResult: ServerCreateUpdatesResponse,
};
export type DeleteEntryResult = {
+newMessageInfos: $ReadOnlyArray,
+threadID: string,
+updatesResult: ClientCreateUpdatesResponse,
};
export type RestoreEntryResponse = {
+newMessageInfos: $ReadOnlyArray,
+updatesResult: ServerCreateUpdatesResponse,
};
export type RestoreEntryResult = {
+newMessageInfos: $ReadOnlyArray,
+updatesResult: ClientCreateUpdatesResponse,
};
export type RestoreEntryPayload = {
...RestoreEntryResult,
+threadID: string,
};
export type FetchEntryInfosBase = {
+rawEntryInfos: $ReadOnlyArray,
};
export type FetchEntryInfosResponse = {
...FetchEntryInfosBase,
+userInfos: { [id: string]: AccountUserInfo },
};
export type FetchEntryInfosResult = FetchEntryInfosBase;
export type DeltaEntryInfosResponse = {
+rawEntryInfos: $ReadOnlyArray,
+deletedEntryIDs: $ReadOnlyArray,
};
export type DeltaEntryInfosResult = {
+rawEntryInfos: $ReadOnlyArray,
+deletedEntryIDs: $ReadOnlyArray,
+userInfos: $ReadOnlyArray,
};
export type CalendarResult = {
+rawEntryInfos: $ReadOnlyArray,
+calendarQuery: CalendarQuery,
};
export type CalendarQueryUpdateStartingPayload = {
+calendarQuery?: CalendarQuery,
};
export type CalendarQueryUpdateResult = {
+rawEntryInfos: $ReadOnlyArray,
+deletedEntryIDs: $ReadOnlyArray,
+calendarQuery: CalendarQuery,
+calendarQueryAlreadyUpdated: boolean,
};
diff --git a/lib/types/message-types.js b/lib/types/message-types.js
index 0920a1556..2bdea45c4 100644
--- a/lib/types/message-types.js
+++ b/lib/types/message-types.js
@@ -1,697 +1,719 @@
// @flow
import invariant from 'invariant';
import t, {
type TUnion,
type TDict,
type TEnums,
type TInterface,
} from 'tcomb';
import { type ClientDBMediaInfo } from './media-types.js';
import { messageTypes, type MessageType } from './message-types-enum.js';
import {
type AddMembersMessageData,
type AddMembersMessageInfo,
type RawAddMembersMessageInfo,
rawAddMembersMessageInfoValidator,
} from './messages/add-members.js';
import {
type ChangeRoleMessageData,
type ChangeRoleMessageInfo,
type RawChangeRoleMessageInfo,
rawChangeRoleMessageInfoValidator,
} from './messages/change-role.js';
import {
type ChangeSettingsMessageData,
type ChangeSettingsMessageInfo,
type RawChangeSettingsMessageInfo,
rawChangeSettingsMessageInfoValidator,
} from './messages/change-settings.js';
import {
type CreateEntryMessageData,
type CreateEntryMessageInfo,
type RawCreateEntryMessageInfo,
rawCreateEntryMessageInfoValidator,
} from './messages/create-entry.js';
import {
type CreateSidebarMessageData,
type CreateSidebarMessageInfo,
type RawCreateSidebarMessageInfo,
rawCreateSidebarMessageInfoValidator,
} from './messages/create-sidebar.js';
import {
type CreateSubthreadMessageData,
type CreateSubthreadMessageInfo,
type RawCreateSubthreadMessageInfo,
rawCreateSubthreadMessageInfoValidator,
} from './messages/create-subthread.js';
import {
type CreateThreadMessageData,
type CreateThreadMessageInfo,
type RawCreateThreadMessageInfo,
rawCreateThreadMessageInfoValidator,
} from './messages/create-thread.js';
import {
type DeleteEntryMessageData,
type DeleteEntryMessageInfo,
type RawDeleteEntryMessageInfo,
rawDeleteEntryMessageInfoValidator,
} from './messages/delete-entry.js';
import {
type EditEntryMessageData,
type EditEntryMessageInfo,
type RawEditEntryMessageInfo,
rawEditEntryMessageInfoValidator,
} from './messages/edit-entry.js';
import {
type RawEditMessageInfo,
rawEditMessageInfoValidator,
type EditMessageData,
type EditMessageInfo,
} from './messages/edit.js';
import {
type ImagesMessageData,
type ImagesMessageInfo,
type RawImagesMessageInfo,
rawImagesMessageInfoValidator,
} from './messages/images.js';
import {
type JoinThreadMessageData,
type JoinThreadMessageInfo,
type RawJoinThreadMessageInfo,
rawJoinThreadMessageInfoValidator,
} from './messages/join-thread.js';
import {
type LeaveThreadMessageData,
type LeaveThreadMessageInfo,
type RawLeaveThreadMessageInfo,
rawLeaveThreadMessageInfoValidator,
} from './messages/leave-thread.js';
import {
type MediaMessageData,
type MediaMessageInfo,
type MediaMessageServerDBContent,
type RawMediaMessageInfo,
rawMediaMessageInfoValidator,
} from './messages/media.js';
import {
type ReactionMessageData,
type RawReactionMessageInfo,
rawReactionMessageInfoValidator,
type ReactionMessageInfo,
} from './messages/reaction.js';
import {
type RawRemoveMembersMessageInfo,
rawRemoveMembersMessageInfoValidator,
type RemoveMembersMessageData,
type RemoveMembersMessageInfo,
} from './messages/remove-members.js';
import {
type RawRestoreEntryMessageInfo,
rawRestoreEntryMessageInfoValidator,
type RestoreEntryMessageData,
type RestoreEntryMessageInfo,
} from './messages/restore-entry.js';
import {
type RawTextMessageInfo,
rawTextMessageInfoValidator,
type TextMessageData,
type TextMessageInfo,
} from './messages/text.js';
import {
type TogglePinMessageData,
type TogglePinMessageInfo,
type RawTogglePinMessageInfo,
rawTogglePinMessageInfoValidator,
} from './messages/toggle-pin.js';
import {
type RawUnsupportedMessageInfo,
rawUnsupportedMessageInfoValidator,
type UnsupportedMessageInfo,
} from './messages/unsupported.js';
import {
type RawUpdateRelationshipMessageInfo,
rawUpdateRelationshipMessageInfoValidator,
type UpdateRelationshipMessageData,
type UpdateRelationshipMessageInfo,
} from './messages/update-relationship.js';
import { type RelativeUserInfo, type UserInfos } from './user-types.js';
import type { CallServerEndpointResultInfoInterface } from '../utils/call-server-endpoint.js';
import { values } from '../utils/objects.js';
import { tNumber, tShape, tID } from '../utils/validation-utils.js';
const composableMessageTypes = new Set([
messageTypes.TEXT,
messageTypes.IMAGES,
messageTypes.MULTIMEDIA,
]);
export function isComposableMessageType(ourMessageType: MessageType): boolean {
return composableMessageTypes.has(ourMessageType);
}
export function assertComposableMessageType(
ourMessageType: MessageType,
): MessageType {
invariant(
isComposableMessageType(ourMessageType),
'MessageType is not composed',
);
return ourMessageType;
}
export function assertComposableRawMessage(
message: RawMessageInfo,
): RawComposableMessageInfo {
invariant(
message.type === messageTypes.TEXT ||
message.type === messageTypes.IMAGES ||
message.type === messageTypes.MULTIMEDIA,
'Message is not composable',
);
return message;
}
export function messageDataLocalID(messageData: MessageData): ?string {
if (
messageData.type !== messageTypes.TEXT &&
messageData.type !== messageTypes.IMAGES &&
messageData.type !== messageTypes.MULTIMEDIA &&
messageData.type !== messageTypes.REACTION
) {
return null;
}
return messageData.localID;
}
export function isMessageSidebarSourceReactionOrEdit(
message: RawMessageInfo | MessageInfo,
): boolean %checks {
return (
message.type === messageTypes.SIDEBAR_SOURCE ||
message.type === messageTypes.REACTION ||
message.type === messageTypes.EDIT_MESSAGE
);
}
const mediaMessageTypes = new Set([
messageTypes.IMAGES,
messageTypes.MULTIMEDIA,
]);
export function isMediaMessageType(ourMessageType: MessageType): boolean {
return mediaMessageTypes.has(ourMessageType);
}
export function assertMediaMessageType(
ourMessageType: MessageType,
): MessageType {
invariant(isMediaMessageType(ourMessageType), 'MessageType is not media');
return ourMessageType;
}
// *MessageData = passed to createMessages function to insert into database
// Raw*MessageInfo = used by server, and contained in client's local store
// *MessageInfo = used by client in UI code
export type SidebarSourceMessageData = {
+type: 17,
+threadID: string,
+creatorID: string,
+time: number,
+sourceMessage?: RawComposableMessageInfo | RawRobotextMessageInfo,
};
export type MessageData =
| TextMessageData
| CreateThreadMessageData
| AddMembersMessageData
| CreateSubthreadMessageData
| ChangeSettingsMessageData
| RemoveMembersMessageData
| ChangeRoleMessageData
| LeaveThreadMessageData
| JoinThreadMessageData
| CreateEntryMessageData
| EditEntryMessageData
| DeleteEntryMessageData
| RestoreEntryMessageData
| ImagesMessageData
| MediaMessageData
| UpdateRelationshipMessageData
| SidebarSourceMessageData
| CreateSidebarMessageData
| ReactionMessageData
| EditMessageData
| TogglePinMessageData;
export type MultimediaMessageData = ImagesMessageData | MediaMessageData;
export type RawMultimediaMessageInfo =
| RawImagesMessageInfo
| RawMediaMessageInfo;
export const rawMultimediaMessageInfoValidator: TUnion =
t.union([rawImagesMessageInfoValidator, rawMediaMessageInfoValidator]);
export type RawComposableMessageInfo =
| RawTextMessageInfo
| RawMultimediaMessageInfo;
const rawComposableMessageInfoValidator = t.union([
rawTextMessageInfoValidator,
rawMultimediaMessageInfoValidator,
]);
export type RawRobotextMessageInfo =
| RawCreateThreadMessageInfo
| RawAddMembersMessageInfo
| RawCreateSubthreadMessageInfo
| RawChangeSettingsMessageInfo
| RawRemoveMembersMessageInfo
| RawChangeRoleMessageInfo
| RawLeaveThreadMessageInfo
| RawJoinThreadMessageInfo
| RawCreateEntryMessageInfo
| RawEditEntryMessageInfo
| RawDeleteEntryMessageInfo
| RawRestoreEntryMessageInfo
| RawUpdateRelationshipMessageInfo
| RawCreateSidebarMessageInfo
| RawUnsupportedMessageInfo
| RawTogglePinMessageInfo;
const rawRobotextMessageInfoValidator = t.union([
rawCreateThreadMessageInfoValidator,
rawAddMembersMessageInfoValidator,
rawCreateSubthreadMessageInfoValidator,
rawChangeSettingsMessageInfoValidator,
rawRemoveMembersMessageInfoValidator,
rawChangeRoleMessageInfoValidator,
rawLeaveThreadMessageInfoValidator,
rawJoinThreadMessageInfoValidator,
rawCreateEntryMessageInfoValidator,
rawEditEntryMessageInfoValidator,
rawDeleteEntryMessageInfoValidator,
rawRestoreEntryMessageInfoValidator,
rawUpdateRelationshipMessageInfoValidator,
rawCreateSidebarMessageInfoValidator,
rawUnsupportedMessageInfoValidator,
rawTogglePinMessageInfoValidator,
]);
export type RawSidebarSourceMessageInfo = {
...SidebarSourceMessageData,
id: string,
};
export const rawSidebarSourceMessageInfoValidator: TInterface =
tShape({
type: tNumber(messageTypes.SIDEBAR_SOURCE),
threadID: tID,
creatorID: t.String,
time: t.Number,
sourceMessage: t.maybe(
t.union([
rawComposableMessageInfoValidator,
rawRobotextMessageInfoValidator,
]),
),
id: tID,
});
export type RawMessageInfo =
| RawComposableMessageInfo
| RawRobotextMessageInfo
| RawSidebarSourceMessageInfo
| RawReactionMessageInfo
| RawEditMessageInfo;
export const rawMessageInfoValidator: TUnion = t.union([
rawComposableMessageInfoValidator,
rawRobotextMessageInfoValidator,
rawSidebarSourceMessageInfoValidator,
rawReactionMessageInfoValidator,
rawEditMessageInfoValidator,
]);
export type LocallyComposedMessageInfo =
| ({
...RawImagesMessageInfo,
+localID: string,
} & RawImagesMessageInfo)
| ({
...RawMediaMessageInfo,
+localID: string,
} & RawMediaMessageInfo)
| ({
...RawTextMessageInfo,
+localID: string,
} & RawTextMessageInfo)
| ({
...RawReactionMessageInfo,
+localID: string,
} & RawReactionMessageInfo);
export type MultimediaMessageInfo = ImagesMessageInfo | MediaMessageInfo;
export type ComposableMessageInfo = TextMessageInfo | MultimediaMessageInfo;
export type RobotextMessageInfo =
| CreateThreadMessageInfo
| AddMembersMessageInfo
| CreateSubthreadMessageInfo
| ChangeSettingsMessageInfo
| RemoveMembersMessageInfo
| ChangeRoleMessageInfo
| LeaveThreadMessageInfo
| JoinThreadMessageInfo
| CreateEntryMessageInfo
| EditEntryMessageInfo
| DeleteEntryMessageInfo
| RestoreEntryMessageInfo
| UnsupportedMessageInfo
| UpdateRelationshipMessageInfo
| CreateSidebarMessageInfo
| TogglePinMessageInfo;
export type PreviewableMessageInfo =
| RobotextMessageInfo
| MultimediaMessageInfo
| ReactionMessageInfo;
export type SidebarSourceMessageInfo = {
+type: 17,
+id: string,
+threadID: string,
+creator: RelativeUserInfo,
+time: number,
+sourceMessage: ComposableMessageInfo | RobotextMessageInfo,
};
export type MessageInfo =
| ComposableMessageInfo
| RobotextMessageInfo
| SidebarSourceMessageInfo
| ReactionMessageInfo
| EditMessageInfo;
export type ThreadMessageInfo = {
messageIDs: string[],
startReached: boolean,
lastNavigatedTo: number, // millisecond timestamp
lastPruned: number, // millisecond timestamp
};
+const threadMessageInfoValidator: TInterface =
+ tShape({
+ messageIDs: t.list(tID),
+ startReached: t.Boolean,
+ lastNavigatedTo: t.Number,
+ lastPruned: t.Number,
+ });
// Tracks client-local information about a message that hasn't been assigned an
// ID by the server yet. As soon as the client gets an ack from the server for
// this message, it will clear the LocalMessageInfo.
export type LocalMessageInfo = {
+sendFailed?: boolean,
};
+const localMessageInfoValidator: TInterface =
+ tShape({
+ sendFailed: t.maybe(t.Boolean),
+ });
export type MessageStoreThreads = {
+[threadID: string]: ThreadMessageInfo,
};
+const messageStoreThreadsValidator: TDict = t.dict(
+ tID,
+ threadMessageInfoValidator,
+);
export type MessageStore = {
+messages: { +[id: string]: RawMessageInfo },
+threads: MessageStoreThreads,
+local: { +[id: string]: LocalMessageInfo },
+currentAsOf: number,
};
+export const messageStoreValidator: TInterface =
+ tShape({
+ messages: t.dict(tID, rawMessageInfoValidator),
+ threads: messageStoreThreadsValidator,
+ local: t.dict(t.String, localMessageInfoValidator),
+ currentAsOf: t.Number,
+ });
// MessageStore messages ops
export type RemoveMessageOperation = {
+type: 'remove',
+payload: { +ids: $ReadOnlyArray },
};
export type RemoveMessagesForThreadsOperation = {
+type: 'remove_messages_for_threads',
+payload: { +threadIDs: $ReadOnlyArray },
};
export type ReplaceMessageOperation = {
+type: 'replace',
+payload: { +id: string, +messageInfo: RawMessageInfo },
};
export type RekeyMessageOperation = {
+type: 'rekey',
+payload: { +from: string, +to: string },
};
export type RemoveAllMessagesOperation = {
+type: 'remove_all',
};
// MessageStore threads ops
export type ReplaceMessageStoreThreadsOperation = {
+type: 'replace_threads',
+payload: { +threads: MessageStoreThreads },
};
export type RemoveMessageStoreThreadsOperation = {
+type: 'remove_threads',
+payload: { +ids: $ReadOnlyArray },
};
export type RemoveMessageStoreAllThreadsOperation = {
+type: 'remove_all_threads',
};
// We were initially using `number`s` for `thread`, `type`, `future_type`, etc.
// However, we ended up changing `thread` to `string` to account for thread IDs
// including information about the keyserver (eg 'GENESIS|123') in the future.
//
// At that point we discussed whether we should switch the remaining `number`
// fields to `string`s for consistency and flexibility. We researched whether
// there was any performance cost to using `string`s instead of `number`s and
// found the differences to be negligible. We also concluded using `string`s
// may be safer after considering `jsi::Number` and the various C++ number
// representations on the CommCoreModule side.
export type ClientDBMessageInfo = {
+id: string,
+local_id: ?string,
+thread: string,
+user: string,
+type: string,
+future_type: ?string,
+content: ?string,
+time: string,
+media_infos: ?$ReadOnlyArray,
};
export type ClientDBReplaceMessageOperation = {
+type: 'replace',
+payload: ClientDBMessageInfo,
};
export type ClientDBThreadMessageInfo = {
+id: string,
+start_reached: string,
+last_navigated_to: string,
+last_pruned: string,
};
export type ClientDBReplaceThreadsOperation = {
+type: 'replace_threads',
+payload: { +threads: $ReadOnlyArray },
};
export type MessageStoreOperation =
| RemoveMessageOperation
| ReplaceMessageOperation
| RekeyMessageOperation
| RemoveMessagesForThreadsOperation
| RemoveAllMessagesOperation
| ReplaceMessageStoreThreadsOperation
| RemoveMessageStoreThreadsOperation
| RemoveMessageStoreAllThreadsOperation;
export type ClientDBMessageStoreOperation =
| RemoveMessageOperation
| ClientDBReplaceMessageOperation
| RekeyMessageOperation
| RemoveMessagesForThreadsOperation
| RemoveAllMessagesOperation
| ClientDBReplaceThreadsOperation
| RemoveMessageStoreThreadsOperation
| RemoveMessageStoreAllThreadsOperation;
export const messageTruncationStatus = Object.freeze({
// EXHAUSTIVE means we've reached the start of the thread. Either the result
// set includes the very first message for that thread, or there is nothing
// behind the cursor you queried for. Given that the client only ever issues
// ranged queries whose range, when unioned with what is in state, represent
// the set of all messages for a given thread, we can guarantee that getting
// EXHAUSTIVE means the start has been reached.
EXHAUSTIVE: 'exhaustive',
// TRUNCATED is rare, and means that the server can't guarantee that the
// result set for a given thread is contiguous with what the client has in its
// state. If the client can't verify the contiguousness itself, it needs to
// replace its Redux store's contents with what it is in this payload.
// 1) getMessageInfosSince: Result set for thread is equal to max, and the
// truncation status isn't EXHAUSTIVE (ie. doesn't include the very first
// message).
// 2) getMessageInfos: MessageSelectionCriteria does not specify cursors, the
// result set for thread is equal to max, and the truncation status isn't
// EXHAUSTIVE. If cursors are specified, we never return truncated, since
// the cursor given us guarantees the contiguousness of the result set.
// Note that in the reducer, we can guarantee contiguousness if there is any
// intersection between messageIDs in the result set and the set currently in
// the Redux store.
TRUNCATED: 'truncated',
// UNCHANGED means the result set is guaranteed to be contiguous with what the
// client has in its state, but is not EXHAUSTIVE. Basically, it's anything
// that isn't either EXHAUSTIVE or TRUNCATED.
UNCHANGED: 'unchanged',
});
export type MessageTruncationStatus = $Values;
export function assertMessageTruncationStatus(
ourMessageTruncationStatus: string,
): MessageTruncationStatus {
invariant(
ourMessageTruncationStatus === 'truncated' ||
ourMessageTruncationStatus === 'unchanged' ||
ourMessageTruncationStatus === 'exhaustive',
'string is not ourMessageTruncationStatus enum',
);
return ourMessageTruncationStatus;
}
export const messageTruncationStatusValidator: TEnums = t.enums.of(
values(messageTruncationStatus),
);
export type MessageTruncationStatuses = {
[threadID: string]: MessageTruncationStatus,
};
export const messageTruncationStatusesValidator: TDict =
t.dict(tID, messageTruncationStatusValidator);
export type ThreadCursors = { +[threadID: string]: ?string };
export type MessageSelectionCriteria = {
+threadCursors?: ?ThreadCursors,
+joinedThreads?: ?boolean,
+newerThan?: ?number,
};
export type FetchMessageInfosRequest = {
+cursors: ThreadCursors,
+numberPerThread?: ?number,
};
export type FetchMessageInfosResponse = {
+rawMessageInfos: $ReadOnlyArray,
+truncationStatuses: MessageTruncationStatuses,
+userInfos: UserInfos,
};
export type FetchMessageInfosResult = {
+rawMessageInfos: $ReadOnlyArray,
+truncationStatuses: MessageTruncationStatuses,
};
export type FetchMessageInfosPayload = {
+threadID: string,
+rawMessageInfos: $ReadOnlyArray,
+truncationStatus: MessageTruncationStatus,
};
export type MessagesResponse = {
+rawMessageInfos: $ReadOnlyArray,
+truncationStatuses: MessageTruncationStatuses,
+currentAsOf: number,
};
export const messagesResponseValidator: TInterface =
tShape({
rawMessageInfos: t.list(rawMessageInfoValidator),
truncationStatuses: messageTruncationStatusesValidator,
currentAsOf: t.Number,
});
export type SimpleMessagesPayload = {
+rawMessageInfos: $ReadOnlyArray,
+truncationStatuses: MessageTruncationStatuses,
};
export const defaultNumberPerThread = 20;
export const defaultMaxMessageAge = 14 * 24 * 60 * 60 * 1000; // 2 weeks
export type SendMessageResponse = {
+newMessageInfo: RawMessageInfo,
};
export type SendMessageResult = {
+id: string,
+time: number,
+interface: CallServerEndpointResultInfoInterface,
};
export type SendMessagePayload = {
+localID: string,
+serverID: string,
+threadID: string,
+time: number,
+interface: CallServerEndpointResultInfoInterface,
};
export type SendTextMessageRequest = {
+threadID: string,
+localID?: string,
+text: string,
+sidebarCreation?: boolean,
};
export type SendMultimediaMessageRequest =
// This option is only used for messageTypes.IMAGES
| {
+threadID: string,
+localID: string,
+sidebarCreation?: boolean,
+mediaIDs: $ReadOnlyArray,
}
| {
+threadID: string,
+localID: string,
+sidebarCreation?: boolean,
+mediaMessageContents: $ReadOnlyArray,
};
export type SendReactionMessageRequest = {
+threadID: string,
+localID?: string,
+targetMessageID: string,
+reaction: string,
+action: 'add_reaction' | 'remove_reaction',
};
export type SendEditMessageRequest = {
+targetMessageID: string,
+text: string,
};
export type SendEditMessageResponse = {
+newMessageInfos: $ReadOnlyArray,
};
export type EditMessagePayload = SendEditMessageResponse;
export type SendEditMessageResult = SendEditMessageResponse;
export type EditMessageContent = {
+text: string,
};
// Used for the message info included in log-in type actions
export type GenericMessagesResult = {
+messageInfos: RawMessageInfo[],
+truncationStatus: MessageTruncationStatuses,
+watchedIDsAtRequestTime: $ReadOnlyArray,
+currentAsOf: number,
};
export type SaveMessagesPayload = {
+rawMessageInfos: $ReadOnlyArray,
+updatesCurrentAsOf: number,
};
export type NewMessagesPayload = {
+messagesResult: MessagesResponse,
};
export const newMessagesPayloadValidator: TInterface =
tShape({
messagesResult: messagesResponseValidator,
});
export type MessageStorePrunePayload = {
+threadIDs: $ReadOnlyArray,
};
export type FetchPinnedMessagesRequest = {
+threadID: string,
};
export type FetchPinnedMessagesResult = {
+pinnedMessages: $ReadOnlyArray,
};
diff --git a/lib/types/thread-types.js b/lib/types/thread-types.js
index 3faa14fd0..2bff694ce 100644
--- a/lib/types/thread-types.js
+++ b/lib/types/thread-types.js
@@ -1,411 +1,442 @@
// @flow
import t, { type TInterface } from 'tcomb';
import {
type AvatarDBContent,
type ClientAvatar,
clientAvatarValidator,
type UpdateUserAvatarRequest,
} from './avatar-types.js';
import type { Shape } from './core.js';
import type { CalendarQuery, RawEntryInfo } from './entry-types.js';
import type { Media } from './media-types.js';
import type {
MessageTruncationStatuses,
RawMessageInfo,
} from './message-types.js';
import {
type ThreadSubscription,
threadSubscriptionValidator,
} from './subscription-types.js';
import {
type ThreadPermissionsInfo,
type ThreadRolePermissionsBlob,
threadPermissionsInfoValidator,
threadRolePermissionsBlobValidator,
} from './thread-permission-types.js';
import { type ThreadType, threadTypeValidator } from './thread-types-enum.js';
import type { ClientUpdateInfo, ServerUpdateInfo } from './update-types.js';
import type { UserInfo, UserInfos } from './user-types.js';
-import { type ThreadEntity } from '../utils/entity-text.js';
+import {
+ type ThreadEntity,
+ threadEntityValidator,
+} from '../utils/entity-text.js';
import { tID, tShape } from '../utils/validation-utils.js';
export type MemberInfo = {
+id: string,
+role: ?string,
+permissions: ThreadPermissionsInfo,
+isSender: boolean,
};
const memberInfoValidator = tShape({
id: t.String,
role: t.maybe(tID),
permissions: threadPermissionsInfoValidator,
isSender: t.Boolean,
});
export type RelativeMemberInfo = {
...MemberInfo,
+username: ?string,
+isViewer: boolean,
};
+const relativeMemberInfoValidator = tShape({
+ ...memberInfoValidator.meta.props,
+ username: t.maybe(t.String),
+ isViewer: t.Boolean,
+});
export type RoleInfo = {
+id: string,
+name: string,
+permissions: ThreadRolePermissionsBlob,
+isDefault: boolean,
};
const roleInfoValidator = tShape({
id: tID,
name: t.String,
permissions: threadRolePermissionsBlobValidator,
isDefault: t.Boolean,
});
export type ThreadCurrentUserInfo = {
+role: ?string,
+permissions: ThreadPermissionsInfo,
+subscription: ThreadSubscription,
+unread: ?boolean,
};
const threadCurrentUserInfoValidator = tShape({
role: t.maybe(tID),
permissions: threadPermissionsInfoValidator,
subscription: threadSubscriptionValidator,
unread: t.maybe(t.Boolean),
});
export type RawThreadInfo = {
+id: string,
+type: ThreadType,
+name: ?string,
+avatar?: ?ClientAvatar,
+description: ?string,
+color: string, // hex, without "#" or "0x"
+creationTime: number, // millisecond timestamp
+parentThreadID: ?string,
+containingThreadID: ?string,
+community: ?string,
+members: $ReadOnlyArray,
+roles: { +[id: string]: RoleInfo },
+currentUser: ThreadCurrentUserInfo,
+sourceMessageID?: string,
+repliesCount: number,
+pinnedCount?: number,
};
export const rawThreadInfoValidator: TInterface =
tShape({
id: tID,
type: threadTypeValidator,
name: t.maybe(t.String),
avatar: t.maybe(clientAvatarValidator),
description: t.maybe(t.String),
color: t.String,
creationTime: t.Number,
parentThreadID: t.maybe(tID),
containingThreadID: t.maybe(tID),
community: t.maybe(tID),
members: t.list(memberInfoValidator),
roles: t.dict(tID, roleInfoValidator),
currentUser: threadCurrentUserInfoValidator,
sourceMessageID: t.maybe(tID),
repliesCount: t.Number,
pinnedCount: t.maybe(t.Number),
});
export type ThreadInfo = {
+id: string,
+type: ThreadType,
+name: ?string,
+uiName: string | ThreadEntity,
+avatar?: ?ClientAvatar,
+description: ?string,
+color: string, // hex, without "#" or "0x"
+creationTime: number, // millisecond timestamp
+parentThreadID: ?string,
+containingThreadID: ?string,
+community: ?string,
+members: $ReadOnlyArray,
+roles: { +[id: string]: RoleInfo },
+currentUser: ThreadCurrentUserInfo,
+sourceMessageID?: string,
+repliesCount: number,
+pinnedCount?: number,
};
+export const threadInfoValidator: TInterface = tShape({
+ id: tID,
+ type: threadTypeValidator,
+ name: t.maybe(t.String),
+ uiName: t.union([t.String, threadEntityValidator]),
+ avatar: t.maybe(clientAvatarValidator),
+ description: t.maybe(t.String),
+ color: t.String,
+ creationTime: t.Number,
+ parentThreadID: t.maybe(tID),
+ containingThreadID: t.maybe(tID),
+ community: t.maybe(tID),
+ members: t.list(relativeMemberInfoValidator),
+ roles: t.dict(tID, roleInfoValidator),
+ currentUser: threadCurrentUserInfoValidator,
+ sourceMessageID: t.maybe(tID),
+ repliesCount: t.Number,
+ pinnedCount: t.maybe(t.Number),
+});
export type ResolvedThreadInfo = {
+id: string,
+type: ThreadType,
+name: ?string,
+uiName: string,
+avatar?: ?ClientAvatar,
+description: ?string,
+color: string, // hex, without "#" or "0x"
+creationTime: number, // millisecond timestamp
+parentThreadID: ?string,
+containingThreadID: ?string,
+community: ?string,
+members: $ReadOnlyArray,
+roles: { +[id: string]: RoleInfo },
+currentUser: ThreadCurrentUserInfo,
+sourceMessageID?: string,
+repliesCount: number,
+pinnedCount?: number,
};
export type ServerMemberInfo = {
+id: string,
+role: ?string,
+permissions: ThreadPermissionsInfo,
+subscription: ThreadSubscription,
+unread: ?boolean,
+isSender: boolean,
};
export type ServerThreadInfo = {
+id: string,
+type: ThreadType,
+name: ?string,
+avatar?: AvatarDBContent,
+description: ?string,
+color: string, // hex, without "#" or "0x"
+creationTime: number, // millisecond timestamp
+parentThreadID: ?string,
+containingThreadID: ?string,
+community: ?string,
+depth: number,
+members: $ReadOnlyArray,
+roles: { +[id: string]: RoleInfo },
+sourceMessageID?: string,
+repliesCount: number,
+pinnedCount: number,
};
export type ThreadStore = {
+threadInfos: { +[id: string]: RawThreadInfo },
};
+export const threadStoreValidator: TInterface =
+ tShape({
+ threadInfos: t.dict(tID, rawThreadInfoValidator),
+ });
export type RemoveThreadOperation = {
+type: 'remove',
+payload: { +ids: $ReadOnlyArray },
};
export type RemoveAllThreadsOperation = {
+type: 'remove_all',
};
export type ReplaceThreadOperation = {
+type: 'replace',
+payload: { +id: string, +threadInfo: RawThreadInfo },
};
export type ThreadStoreOperation =
| RemoveThreadOperation
| RemoveAllThreadsOperation
| ReplaceThreadOperation;
export type ClientDBThreadInfo = {
+id: string,
+type: number,
+name: ?string,
+avatar?: ?string,
+description: ?string,
+color: string,
+creationTime: string,
+parentThreadID: ?string,
+containingThreadID: ?string,
+community: ?string,
+members: string,
+roles: string,
+currentUser: string,
+sourceMessageID?: string,
+repliesCount: number,
+pinnedCount?: number,
};
export type ClientDBReplaceThreadOperation = {
+type: 'replace',
+payload: ClientDBThreadInfo,
};
export type ClientDBThreadStoreOperation =
| RemoveThreadOperation
| RemoveAllThreadsOperation
| ClientDBReplaceThreadOperation;
export type ThreadDeletionRequest = {
+threadID: string,
+accountPassword: ?string,
};
export type RemoveMembersRequest = {
+threadID: string,
+memberIDs: $ReadOnlyArray,
};
export type RoleChangeRequest = {
+threadID: string,
+memberIDs: $ReadOnlyArray,
+role: string,
};
export type ChangeThreadSettingsResult = {
+threadInfo?: RawThreadInfo,
+threadInfos?: { +[id: string]: RawThreadInfo },
+updatesResult: {
+newUpdates: $ReadOnlyArray,
},
+newMessageInfos: $ReadOnlyArray,
};
export type ChangeThreadSettingsPayload = {
+threadID: string,
+updatesResult: {
+newUpdates: $ReadOnlyArray,
},
+newMessageInfos: $ReadOnlyArray,
};
export type LeaveThreadRequest = {
+threadID: string,
};
export type LeaveThreadResult = {
+threadInfos?: { +[id: string]: RawThreadInfo },
+updatesResult: {
+newUpdates: $ReadOnlyArray,
},
};
export type LeaveThreadPayload = {
+updatesResult: {
+newUpdates: $ReadOnlyArray,
},
};
export type ThreadChanges = Shape<{
+type: ThreadType,
+name: string,
+description: string,
+color: string,
+parentThreadID: ?string,
+newMemberIDs: $ReadOnlyArray,
+avatar: UpdateUserAvatarRequest,
}>;
export type UpdateThreadRequest = {
+threadID: string,
+changes: ThreadChanges,
+accountPassword?: empty,
};
export type BaseNewThreadRequest = {
+id?: ?string,
+name?: ?string,
+description?: ?string,
+color?: ?string,
+parentThreadID?: ?string,
+initialMemberIDs?: ?$ReadOnlyArray,
+ghostMemberIDs?: ?$ReadOnlyArray,
};
type NewThreadRequest =
| {
+type: 3 | 4 | 6 | 7 | 8 | 9 | 10 | 11 | 12,
...BaseNewThreadRequest,
}
| {
+type: 5,
+sourceMessageID: string,
...BaseNewThreadRequest,
};
export type ClientNewThreadRequest = {
...NewThreadRequest,
+calendarQuery: CalendarQuery,
};
export type ServerNewThreadRequest = {
...NewThreadRequest,
+calendarQuery?: ?CalendarQuery,
};
export type NewThreadResponse = {
+updatesResult: {
+newUpdates: $ReadOnlyArray,
},
+newMessageInfos: $ReadOnlyArray,
+newThreadInfo?: RawThreadInfo,
+userInfos: UserInfos,
+newThreadID?: string,
};
export type NewThreadResult = {
+updatesResult: {
+newUpdates: $ReadOnlyArray,
},
+newMessageInfos: $ReadOnlyArray,
+userInfos: UserInfos,
+newThreadID: string,
};
export type ServerThreadJoinRequest = {
+threadID: string,
+calendarQuery?: ?CalendarQuery,
+inviteLinkSecret?: string,
};
export type ClientThreadJoinRequest = {
+threadID: string,
+calendarQuery: CalendarQuery,
+inviteLinkSecret?: string,
};
export type ThreadJoinResult = {
threadInfos?: { +[id: string]: RawThreadInfo },
updatesResult: {
newUpdates: $ReadOnlyArray,
},
rawMessageInfos: $ReadOnlyArray,
truncationStatuses: MessageTruncationStatuses,
userInfos: UserInfos,
rawEntryInfos?: ?$ReadOnlyArray,
};
export type ThreadJoinPayload = {
+updatesResult: {
newUpdates: $ReadOnlyArray,
},
+rawMessageInfos: $ReadOnlyArray,
+truncationStatuses: MessageTruncationStatuses,
+userInfos: $ReadOnlyArray,
};
export type ThreadFetchMediaResult = {
+media: $ReadOnlyArray,
};
export type ThreadFetchMediaRequest = {
+threadID: string,
+limit: number,
+offset: number,
};
export type SidebarInfo = {
+threadInfo: ThreadInfo,
+lastUpdatedTime: number,
+mostRecentNonLocalMessage: ?string,
};
export type ToggleMessagePinRequest = {
+messageID: string,
+action: 'pin' | 'unpin',
};
export type ToggleMessagePinResult = {
+newMessageInfos: $ReadOnlyArray,
+threadID: string,
};
// We can show a max of 3 sidebars inline underneath their parent in the chat
// tab. If there are more, we show a button that opens a modal to see the rest
export const maxReadSidebars = 3;
// We can show a max of 5 sidebars inline underneath their parent
// in the chat tab if every one of the displayed sidebars is unread
export const maxUnreadSidebars = 5;
export type ThreadStoreThreadInfos = { +[id: string]: RawThreadInfo };
diff --git a/lib/utils/entity-text.js b/lib/utils/entity-text.js
index 1894854ef..43520e315 100644
--- a/lib/utils/entity-text.js
+++ b/lib/utils/entity-text.js
@@ -1,546 +1,581 @@
// @flow
import invariant from 'invariant';
import * as React from 'react';
+import t, { type TInterface, type TUnion } from 'tcomb';
import type { GetENSNames } from './ens-helpers.js';
+import { tID, tShape, tString } from './validation-utils.js';
import { useENSNames } from '../hooks/ens-cache.js';
import { threadNoun } from '../shared/thread-utils.js';
import { stringForUser } from '../shared/user-utils.js';
-import { type ThreadType, threadTypes } from '../types/thread-types-enum.js';
+import {
+ type ThreadType,
+ threadTypes,
+ threadTypeValidator,
+} from '../types/thread-types-enum.js';
import { type RawThreadInfo, type ThreadInfo } from '../types/thread-types.js';
import { basePluralize } from '../utils/text-utils.js';
type UserEntity = {
+type: 'user',
+id: string,
+username?: ?string,
+isViewer?: ?boolean,
+possessive?: ?boolean, // eg. `user's` instead of `user`
};
+export const userEntityValidator: TInterface = tShape({
+ type: tString('user'),
+ id: t.String,
+ username: t.maybe(t.String),
+ isViewer: t.maybe(t.Boolean),
+ possessive: t.maybe(t.Boolean),
+});
// Comments explain how thread name will appear from user4's perspective
export type ThreadEntity =
| {
+type: 'thread',
+id: string,
+name?: ?string,
// displays threadInfo.name if set, or 'user1, user2, and user3'
+display: 'uiName',
// If uiName is EntityText, then at render time ThreadEntity will be
// replaced with a pluralized list of uiName's UserEntities
+uiName: $ReadOnlyArray | string,
// If name isn't set and uiName is an array with only the viewer, then
// just_you_string displays "just you" but viewer_username displays the
// viewer's ENS-resolved username. Defaults to just_you_string
+ifJustViewer?: 'just_you_string' | 'viewer_username',
}
| {
+type: 'thread',
+id: string,
+name?: ?string,
// displays threadInfo.name if set, or eg. 'this thread' or 'this chat'
+display: 'shortName',
+threadType?: ?ThreadType,
+parentThreadID?: ?string,
+alwaysDisplayShortName?: ?boolean, // don't default to name
+subchannel?: ?boolean, // short name should be "subchannel"
+possessive?: ?boolean, // eg. `this thread's` instead of `this thread`
};
+export const threadEntityValidator: TUnion = t.union([
+ tShape({
+ type: tString('thread'),
+ id: tID,
+ name: t.maybe(t.String),
+ display: tString('uiName'),
+ uiName: t.union([t.list(userEntityValidator), t.String]),
+ ifJustViewer: t.maybe(t.enums.of(['just_you_string', 'viewer_username'])),
+ }),
+ tShape({
+ type: tString('thread'),
+ id: tID,
+ name: t.maybe(t.String),
+ display: tString('shortName'),
+ threadType: t.maybe(threadTypeValidator),
+ parentThreadID: t.maybe(tID),
+ alwaysDisplayShortName: t.maybe(t.Boolean),
+ subchannel: t.maybe(t.Boolean),
+ possessive: t.maybe(t.Boolean),
+ }),
+]);
+
type ColorEntity = {
+type: 'color',
+hex: string,
};
type EntityTextComponent = UserEntity | ThreadEntity | ColorEntity | string;
export type EntityText = $ReadOnlyArray;
const entityTextFunction = (
strings: $ReadOnlyArray,
...entities: $ReadOnlyArray
) => {
const result = [];
for (let i = 0; i < strings.length; i++) {
const str = strings[i];
if (str) {
result.push(str);
}
const entity = entities[i];
if (!entity) {
continue;
}
if (typeof entity === 'string') {
const lastResult = result.length > 0 && result[result.length - 1];
if (typeof lastResult === 'string') {
result[result.length - 1] = lastResult + entity;
} else {
result.push(entity);
}
} else if (Array.isArray(entity)) {
const [firstEntity, ...restOfEntity] = entity;
const lastResult = result.length > 0 && result[result.length - 1];
if (typeof lastResult === 'string' && typeof firstEntity === 'string') {
result[result.length - 1] = lastResult + firstEntity;
} else if (firstEntity) {
result.push(firstEntity);
}
result.push(...restOfEntity);
} else {
result.push(entity);
}
}
return result;
};
// defaults to shortName
type EntityTextThreadInput =
| {
+display: 'uiName',
+threadInfo: ThreadInfo,
}
| {
+display?: 'shortName',
+threadInfo: ThreadInfo | RawThreadInfo,
+subchannel?: ?boolean,
+possessive?: ?boolean,
}
| {
+display: 'alwaysDisplayShortName',
+threadInfo: ThreadInfo | RawThreadInfo,
+possessive?: ?boolean,
}
| {
+display: 'alwaysDisplayShortName',
+threadID: string,
+parentThreadID?: ?string,
+threadType?: ?ThreadType,
+possessive?: ?boolean,
};
// ESLint doesn't recognize that invariant always throws
// eslint-disable-next-line consistent-return
entityTextFunction.thread = (input: EntityTextThreadInput) => {
if (input.display === 'uiName') {
const { threadInfo } = input;
if (typeof threadInfo.uiName !== 'string') {
return threadInfo.uiName;
}
return {
type: 'thread',
id: threadInfo.id,
name: threadInfo.name,
display: 'uiName',
uiName: threadInfo.uiName,
};
}
if (input.display === 'alwaysDisplayShortName' && input.threadID) {
const { threadID, threadType, parentThreadID, possessive } = input;
return {
type: 'thread',
id: threadID,
name: undefined,
display: 'shortName',
threadType,
parentThreadID,
alwaysDisplayShortName: true,
possessive,
};
} else if (input.display === 'alwaysDisplayShortName' && input.threadInfo) {
const { threadInfo, possessive } = input;
return {
type: 'thread',
id: threadInfo.id,
name: threadInfo.name,
display: 'shortName',
threadType: threadInfo.type,
parentThreadID: threadInfo.parentThreadID,
alwaysDisplayShortName: true,
possessive,
};
} else if (input.display === 'shortName' || !input.display) {
const { threadInfo, subchannel, possessive } = input;
return {
type: 'thread',
id: threadInfo.id,
name: threadInfo.name,
display: 'shortName',
threadType: threadInfo.type,
parentThreadID: threadInfo.parentThreadID,
subchannel,
possessive,
};
}
invariant(
false,
`ET.thread passed unexpected display type: ${input.display}`,
);
};
type EntityTextUserInput = {
+userInfo: {
+id: string,
+username?: ?string,
+isViewer?: ?boolean,
...
},
+possessive?: ?boolean,
};
entityTextFunction.user = (input: EntityTextUserInput) => ({
type: 'user',
id: input.userInfo.id,
username: input.userInfo.username,
isViewer: input.userInfo.isViewer,
possessive: input.possessive,
});
type EntityTextColorInput = { +hex: string };
entityTextFunction.color = (input: EntityTextColorInput) => ({
type: 'color',
hex: input.hex,
});
// ET is a JS tag function used in template literals, eg. ET`something`
// It allows you to compose raw text and "entities" together
type EntityTextFunction = ((
strings: $ReadOnlyArray,
...entities: $ReadOnlyArray
) => EntityText) & {
+thread: EntityTextThreadInput => ThreadEntity,
+user: EntityTextUserInput => UserEntity,
+color: EntityTextColorInput => ColorEntity,
...
};
const ET: EntityTextFunction = entityTextFunction;
type MakePossessiveInput = { +str: string, +isViewer?: ?boolean };
function makePossessive(input: MakePossessiveInput) {
if (input.isViewer) {
return 'your';
}
return `${input.str}’s`;
}
function getNameForThreadEntity(
entity: ThreadEntity,
params?: ?EntityTextToRawStringParams,
): string {
const { name: userGeneratedName, display } = entity;
if (entity.display === 'uiName') {
if (userGeneratedName) {
return userGeneratedName;
}
const { uiName } = entity;
if (typeof uiName === 'string') {
return uiName;
}
let userEntities = uiName;
if (!params?.ignoreViewer) {
const viewerFilteredUserEntities = userEntities.filter(
innerEntity => !innerEntity.isViewer,
);
if (viewerFilteredUserEntities.length > 0) {
userEntities = viewerFilteredUserEntities;
} else if (entity.ifJustViewer === 'viewer_username') {
// We pass ignoreViewer to entityTextToRawString in order
// to prevent it from rendering the viewer as "you"
params = { ...params, ignoreViewer: true };
} else {
return 'just you';
}
}
const pluralized = pluralizeEntityText(
userEntities.map(innerEntity => [innerEntity]),
);
return entityTextToRawString(pluralized, params);
}
invariant(
entity.display === 'shortName',
`getNameForThreadEntity can't handle thread entity display ${display}`,
);
let { name } = entity;
if (!name || entity.alwaysDisplayShortName) {
const threadType = entity.threadType ?? threadTypes.PERSONAL;
const { parentThreadID } = entity;
const noun = entity.subchannel
? 'subchannel'
: threadNoun(threadType, parentThreadID);
if (entity.id === params?.threadID) {
const prefixThisThreadNounWith =
params?.prefixThisThreadNounWith === 'your' ? 'your' : 'this';
name = `${prefixThisThreadNounWith} ${noun}`;
} else {
name = `a ${noun}`;
}
}
if (entity.possessive) {
name = makePossessive({ str: name });
}
return name;
}
function getNameForUserEntity(
entity: UserEntity,
ignoreViewer: ?boolean,
): string {
const isViewer = entity.isViewer && !ignoreViewer;
const entityWithIsViewerIgnored = { ...entity, isViewer };
const str = stringForUser(entityWithIsViewerIgnored);
if (!entityWithIsViewerIgnored.possessive) {
return str;
}
return makePossessive({ str, isViewer });
}
type EntityTextToRawStringParams = {
+threadID?: ?string,
+ignoreViewer?: ?boolean,
+prefixThisThreadNounWith?: ?('this' | 'your'),
};
function entityTextToRawString(
entityText: EntityText,
params?: ?EntityTextToRawStringParams,
): string {
// ESLint doesn't recognize that invariant always throws
// eslint-disable-next-line consistent-return
const textParts = entityText.map(entity => {
if (typeof entity === 'string') {
return entity;
} else if (entity.type === 'thread') {
return getNameForThreadEntity(entity, params);
} else if (entity.type === 'color') {
return entity.hex;
} else if (entity.type === 'user') {
return getNameForUserEntity(entity, params?.ignoreViewer);
} else {
invariant(
false,
`entityTextToRawString can't handle entity type ${entity.type}`,
);
}
});
return textParts.join('');
}
type RenderFunctions = {
+renderText: ({ +text: string }) => React.Node,
+renderThread: ({ +id: string, +name: string }) => React.Node,
+renderColor: ({ +hex: string }) => React.Node,
};
function entityTextToReact(
entityText: EntityText,
threadID: string,
renderFuncs: RenderFunctions,
): React.Node {
const { renderText, renderThread, renderColor } = renderFuncs;
// ESLint doesn't recognize that invariant always throws
// eslint-disable-next-line consistent-return
return entityText.map((entity, i) => {
const key = `text${i}`;
if (typeof entity === 'string') {
return (
{renderText({ text: entity })}
);
} else if (entity.type === 'thread') {
const { id } = entity;
const name = getNameForThreadEntity(entity, { threadID });
if (id === threadID) {
return name;
} else {
return (
{renderThread({ id, name })}
);
}
} else if (entity.type === 'color') {
return (
{renderColor({ hex: entity.hex })}
);
} else if (entity.type === 'user') {
return getNameForUserEntity(entity);
} else {
invariant(
false,
`entityTextToReact can't handle entity type ${entity.type}`,
);
}
});
}
function pluralizeEntityText(
nouns: $ReadOnlyArray,
maxNumberOfNouns: number = 3,
): EntityText {
return basePluralize(
nouns,
maxNumberOfNouns,
(a: EntityText | string, b: ?EntityText | string) =>
b ? ET`${a}${b}` : ET`${a}`,
);
}
type TextEntity = { +type: 'text', +text: string };
type ShadowUserEntity = {
+type: 'shadowUser',
+username: string,
+originalUsername: string,
};
type EntityTextComponentAsObject =
| UserEntity
| ThreadEntity
| ColorEntity
| TextEntity
| ShadowUserEntity;
function entityTextToObjects(
entityText: EntityText,
): EntityTextComponentAsObject[] {
const objs = [];
for (const entity of entityText) {
if (typeof entity === 'string') {
objs.push({ type: 'text', text: entity });
continue;
}
objs.push(entity);
if (
entity.type === 'thread' &&
entity.display === 'uiName' &&
typeof entity.uiName !== 'string'
) {
for (const innerEntity of entity.uiName) {
if (typeof innerEntity === 'string' || innerEntity.type !== 'user') {
continue;
}
const { username } = innerEntity;
if (username) {
objs.push({
type: 'shadowUser',
originalUsername: username,
username,
});
}
}
}
}
return objs;
}
function entityTextFromObjects(
objects: $ReadOnlyArray,
): EntityText {
const shadowUserMap = new Map();
for (const obj of objects) {
if (obj.type === 'shadowUser' && obj.username !== obj.originalUsername) {
shadowUserMap.set(obj.originalUsername, obj.username);
}
}
return objects
.map(entity => {
if (entity.type === 'text') {
return entity.text;
} else if (entity.type === 'shadowUser') {
return null;
} else if (
entity.type === 'thread' &&
entity.display === 'uiName' &&
typeof entity.uiName !== 'string'
) {
const uiName = [];
let changeOccurred = false;
for (const innerEntity of entity.uiName) {
if (typeof innerEntity === 'string' || innerEntity.type !== 'user') {
uiName.push(innerEntity);
continue;
}
const { username } = innerEntity;
if (!username) {
uiName.push(innerEntity);
continue;
}
const ensName = shadowUserMap.get(username);
if (!ensName) {
uiName.push(innerEntity);
continue;
}
changeOccurred = true;
uiName.push({
...innerEntity,
username: ensName,
});
}
if (!changeOccurred) {
return entity;
}
return {
...entity,
uiName,
};
} else {
return entity;
}
})
.filter(Boolean);
}
function useENSNamesForEntityText(entityText: ?EntityText): ?EntityText {
const allObjects = React.useMemo(
() => (entityText ? entityTextToObjects(entityText) : []),
[entityText],
);
const objectsWithENSNames = useENSNames(allObjects);
return React.useMemo(
() =>
entityText ? entityTextFromObjects(objectsWithENSNames) : entityText,
[entityText, objectsWithENSNames],
);
}
function useEntityTextAsString(
entityText: ?EntityText,
params?: EntityTextToRawStringParams,
): ?string {
const withENSNames = useENSNamesForEntityText(entityText);
return React.useMemo(() => {
if (!withENSNames) {
return withENSNames;
}
return entityTextToRawString(withENSNames, params);
}, [withENSNames, params]);
}
async function getEntityTextAsString(
entityText: ?EntityText,
getENSNames: ?GetENSNames,
params?: EntityTextToRawStringParams,
): Promise {
if (!entityText) {
return entityText;
}
let resolvedEntityText = entityText;
if (getENSNames) {
const allObjects = entityTextToObjects(entityText);
const objectsWithENSNames = await getENSNames(allObjects);
resolvedEntityText = entityTextFromObjects(objectsWithENSNames);
}
return entityTextToRawString(resolvedEntityText, params);
}
export {
ET,
entityTextToRawString,
entityTextToReact,
pluralizeEntityText,
useENSNamesForEntityText,
useEntityTextAsString,
getEntityTextAsString,
};
diff --git a/web/types/nav-types.js b/web/types/nav-types.js
index 80245def1..6d47e25cf 100644
--- a/web/types/nav-types.js
+++ b/web/types/nav-types.js
@@ -1,20 +1,43 @@
// @flow
+import t from 'tcomb';
+import type { TInterface } from 'tcomb';
-import type { BaseNavInfo } from 'lib/types/nav-types.js';
-import type { ThreadInfo } from 'lib/types/thread-types.js';
+import { type BaseNavInfo } from 'lib/types/nav-types.js';
+import {
+ type ThreadInfo,
+ threadInfoValidator,
+} from 'lib/types/thread-types.js';
+import { tID, tShape } from 'lib/utils/validation-utils.js';
export type NavigationTab = 'calendar' | 'chat' | 'settings';
+const navigationTabValidator = t.enums.of(['calendar', 'chat', 'settings']);
export type NavigationSettingsSection = 'account' | 'danger-zone';
+const navigationSettingsSectionValidator = t.enums.of([
+ 'account',
+ 'danger-zone',
+]);
export type NavigationChatMode = 'view' | 'create';
+const navigationChatModeValidator = t.enums.of(['view', 'create']);
export type NavInfo = {
...$Exact,
+tab: NavigationTab,
+activeChatThreadID: ?string,
+pendingThread?: ThreadInfo,
+settingsSection?: NavigationSettingsSection,
+selectedUserList?: $ReadOnlyArray,
+chatMode?: NavigationChatMode,
};
+
+export const navInfoValidator: TInterface = tShape<$Exact>({
+ startDate: t.String,
+ endDate: t.String,
+ tab: navigationTabValidator,
+ activeChatThreadID: t.maybe(tID),
+ pendingThread: t.maybe(threadInfoValidator),
+ settingsSection: t.maybe(navigationSettingsSectionValidator),
+ selectedUserList: t.maybe(t.list(t.String)),
+ chatMode: t.maybe(navigationChatModeValidator),
+});
