adding in search and router

packages/desktop/src/providers/RouterProvider.tsx

@@ -0,0 +1,30 @@
+// make do router given absense of react router in desktop apps
+
+import React, { useState } from 'react';
+
+export enum EPage {
+  START_NEW_CONVERSATION = 'START_NEW_CONVERSATION',
+  FULL_PAGE_OMNI_SEARCH = 'FULL_PAGE_OMNI_SEARCH',
+  CONVERSATION_DETAILS = 'CONVERSATION_DETAILS',
+  PROFILE = 'PROFILE',
+  WELCOME = 'WELCOME',
+}
+
+interface IRouterContext {
+  page: EPage;
+  setPage?: React.Dispatch<React.SetStateAction<EPage>>;
+}
+
+const RouterContext = React.createContext<IRouterContext>({
+  page: EPage.START_NEW_CONVERSATION,
+});
+
+export function RouterProvider({ children }: { children: React.ReactNode }) {
+  const [page, setPage] = useState<EPage>(EPage.START_NEW_CONVERSATION);
+
+  return <RouterContext.Provider value={{ page, setPage }}>{children}</RouterContext.Provider>;
+}
+
+export default function useRouter() {
+  return React.useContext(RouterContext);
+}

packages/desktop/src/providers/SearchProvider.tsx

@@ -0,0 +1,147 @@
+import React, { useCallback, useContext, useState } from 'react';
+
+import Conversation from '@nirvana/core/models/conversation.model';
+import { ConversationMap } from '../util/types';
+import User from '@nirvana/core/models/user.model';
+import useAuth from './AuthProvider';
+import { useDebounce } from 'react-use';
+
+interface ISearchContext {
+  searchUsers?: (searchQuery: string) => void;
+  omniSearch?: (searchQuery: string) => void;
+  searchConversations?: (searchQuery: string) => void;
+
+  conversationResults: Conversation[];
+  userResults: User[];
+
+  isSearching: boolean;
+
+  // transparency into what our search is searching for
+  searchQuery: string;
+  clearSearch?: () => void;
+}
+
+const SearchContext = React.createContext<ISearchContext>({
+  isSearching: false,
+  conversationResults: [],
+  userResults: [],
+  searchQuery: '',
+});
+
+export function SearchProvider({ children }: { children: React.ReactNode }) {
+  const { user } = useAuth();
+  // const { conversationMap } = useConversations();
+
+  const [searchQuery, setSearchQuery] = useState<string>('');
+
+  const [userResults, setUserResultsResults] = useState<User[]>([]);
+  const [conversationResults, setConversationResultsResults] = useState<Conversation[]>([]);
+  const [isSearching, setIsSearching] = useState<boolean>(false);
+
+  // debounce user search and any other async ones
+  const [, cancel] = useDebounce(
+    async () => {
+      if (searchQuery) {
+        // let results = await firestoreSearchUsers(searchQuery);
+        // results = results.filter((userResult) => userResult. user._id);
+
+        const results = [];
+        setUserResultsResults(results);
+
+        console.warn('searched users', results);
+      }
+
+      setIsSearching(false);
+    },
+    1000,
+    [searchQuery, setUserResultsResults, user, setIsSearching],
+  );
+
+  // any view will hit this when they want and start the debounce process
+  const searchUsers = useCallback(
+    (searchQuery: string) => {
+      setSearchQuery(searchQuery);
+      setIsSearching(true);
+    },
+    [setSearchQuery, setIsSearching],
+  );
+
+  /**
+   *
+   * @param searchQuery
+   * given a search query, finds conversations
+   */
+
+  const searchRelevantConversations = useCallback(
+    async (searchQuery: string): Promise<Conversation[]> => {
+      const relevantConversations: Conversation[] = [];
+
+      // Object.values(conversationMap).forEach((conversation) => {
+      //   for (const cachedConversationUser of conversation.userCache) {
+      //     if (
+      //       cachedConversationUser.email
+      //         .toLocaleLowerCase()
+      //         .includes(searchQuery.toLocaleLowerCase())
+      //     ) {
+      //       relevantConversations.push(conversation);
+      //       return;
+      //     }
+
+      //     if (
+      //       cachedConversationUser.displayName
+      //         .toLocaleLowerCase()
+      //         .includes(searchQuery.toLocaleLowerCase())
+      //     ) {
+      //       relevantConversations.push(conversation);
+      //       return;
+      //     }
+      //   }
+
+      //   if (conversation.name?.toLocaleLowerCase().includes(searchQuery.toLocaleLowerCase())) {
+      //     relevantConversations.push(conversation);
+      //     return;
+      //   }
+      // });
+
+      return relevantConversations;
+    },
+    [],
+  );
+
+  const omniSearch = useCallback(
+    async (searchQuery: string) => {
+      searchQuery = searchQuery.replace('/', '');
+      setSearchQuery(searchQuery);
+
+      // user search
+      setIsSearching(true);
+
+      // client side conversation search
+      const relevantConversations = await searchRelevantConversations(searchQuery);
+      setConversationResultsResults(relevantConversations);
+    },
+    [setIsSearching, setSearchQuery, setConversationResultsResults, searchRelevantConversations],
+  );
+
+  const clearSearch = useCallback(() => setSearchQuery(''), [setSearchQuery]);
+
+  return (
+    <SearchContext.Provider
+      value={{
+        isSearching,
+        omniSearch,
+        searchUsers,
+        userResults,
+        conversationResults,
+        searchQuery,
+        clearSearch,
+      }}
+    >
+      {children}
+    </SearchContext.Provider>
+  );
+}
+
+export default function useSearch() {
+  return useContext(SearchContext);
+}