chat 1.0.8 → 3.0.0

package/lib/typescript/hooks/index.d.ts

@@ -1,8 +0,0 @@
-export { default as useMessages } from './useMessages';
-export { default as useRoom } from './useRoom';
-export { default as useTyping } from './useTyping';
-export { default as useInbox } from './useInbox';
-export { default as useCreator } from './useCreator';
-export { default as useViewMessages } from './useViewMessages';
-export { default as useSendToPeople } from './useSend/useSendToPeople';
-export { default as useSendToGroup } from './useSend/useSendToGroup';

package/lib/typescript/hooks/useCreator/index.d.ts

@@ -1,27 +0,0 @@
-import { MutableRefObject } from 'react';
-import { RoomCreatorRef } from '../../components/RoomCreator/types';
-declare const _default: () => [MutableRefObject<RoomCreatorRef | undefined>, {
-    open: () => void;
-    close: () => void;
-}];
-/**
- * React hook for managing RoomCreator component in usechat
- *
- * @returns An array with a ref and then convenience functions for the creator
- * [ref, { open, close }]
- *
- * **Required** In order for the methods to work, you must pass creator to sheetRef prop.
- *
- * @example
- * ```javascript
- * export default () => {
- * 	const [creator, { open, close }]
- *
- * 	// ...some other method
- *  const onPress = () => open()
- *
- * 	return <RoomCreator sheetRef={creator} />
- * }
- * ```
- */
-export default _default;

package/lib/typescript/hooks/useInbox/index.d.ts

@@ -1,29 +0,0 @@
-import { QueryDataHandler } from '@nandorojo/fuego/lib/typescript/hooks/useFuego/types';
-import { ExistingRoomDocument } from '../../classes/Room/types';
-import { InboxModel } from '../../classes/Inbox/types';
-import { UseInboxConfig } from './types';
-declare const _default: (config?: UseInboxConfig, options?: QueryDataHandler<ExistingRoomDocument>) => {
-    path: string;
-    loading: boolean;
-    error: import("@nandorojo/fuego/lib/typescript/hooks/useFuego/types").QueryError;
-    db: import("firebase").firestore.Firestore;
-    ref: import("@nandorojo/fuego").FirestoreRefType;
-    unsubscribe: (name: string) => void;
-    exists: boolean | null;
-    refetch: () => void;
-    data: InboxModel;
-};
-/**
- * React hook to query the chat inbox in realtime. Used with the [Juice.Inbox] component from Juice.
- *
- * @example
- * ```
- * const { data } = useInbox()
- *
- * return <Juice.Inbox rooms={data} />
- * ```
- *
- * @returns
- * { data, loading, path, error } and other values returned by useFuego() hook. Data is properly formatted for rendering.
- */
-export default _default;

package/lib/typescript/hooks/useInbox/types.d.ts

@@ -1,5 +0,0 @@
-import { FuegoQueryConfig } from '@nandorojo/fuego/lib/typescript/FuegoQuery/types';
-export interface UseInboxConfig extends Omit<FuegoQueryConfig, 'path'> {
-    uid?: string;
-    listen?: boolean;
-}

package/lib/typescript/hooks/useMessages/index.d.ts

@@ -1,24 +0,0 @@
-import { UseMessagesConfig } from './types';
-import { NewMessageModel, EditMessageModel, MessageModelDocument } from '../../classes/Message/types';
-import { QueryDataHandler } from '@nandorojo/fuego/lib/typescript/hooks/useFuego/types';
-declare const _default: ({ id, ...config }: UseMessagesConfig, options?: QueryDataHandler<MessageModelDocument>) => {
-    data: NewMessageModel[];
-    loading: boolean;
-    error: import("@nandorojo/fuego/lib/typescript/hooks/useFuego/types").QueryError;
-    ref: import("@nandorojo/fuego").FirestoreRefType;
-    path: string;
-    empty: boolean;
-    send: (message: NewMessageModel[]) => void;
-    edit: (message: EditMessageModel) => Promise<void>;
-    fetchMore: () => void;
-    fetchingMore: number | false;
-};
-/**
- *	React hook to set up a lisener for a room's messages
- *
- * 	@param { id } the roomId, along with other query options from `useFuego` hook
- *
- *	@returns { data: formattedMessages, loading, error, ref, path, empty, send, edit, fetchMore }
- * data is formatted for rendering.
- */
-export default _default;

package/lib/typescript/hooks/useMessages/types.d.ts

@@ -1,5 +0,0 @@
-import { FuegoQueryConfig } from '@nandorojo/fuego/lib/typescript/FuegoQuery/types';
-export interface UseMessagesConfig extends Omit<FuegoQueryConfig, 'path'> {
-    id: string;
-    listen?: boolean;
-}

package/lib/typescript/hooks/useRoom/index.d.ts

@@ -1,26 +0,0 @@
-import { EditRoomModel, CreateCallableRoomModel, ExistingRoomDocument, ExistingRoomModel } from '../../classes/Room/types';
-import { UseRoomType } from './types';
-import { QueryDataHandler } from '@nandorojo/fuego/lib/typescript/hooks/useFuego/types';
-declare const _default: ({ id, ...config }: UseRoomType, options?: QueryDataHandler<ExistingRoomDocument>) => {
-    data: ExistingRoomModel | null;
-    loading: boolean;
-    error: import("@nandorojo/fuego/lib/typescript/hooks/useFuego/types").QueryError;
-    ref: import("@nandorojo/fuego").FirestoreRefType;
-    create: (room: CreateCallableRoomModel) => Promise<import("firebase").functions.HttpsCallableResult>;
-    edit: (room: EditRoomModel) => Promise<void> | null;
-    usersAreTyping: boolean;
-    namesOfUsersTyping: string[];
-};
-/**
- * Fetches or subscribes to a chatroom. It automatically handles unmounts, etc.
- *
- * @param config - config dictionary.
- * @param config.id - Required: the unique ID for this chatroom, typically generated by the backend. If using the [[useInbox]] hook, each item in [[useInbox]]'s data array has this ID.
- * @param config.listen Boolean to determine if this room should update state as a subscription. Default false.
- * @param options - added options dictionary for useRoom
- *
- * @remarks Look at the fuego library's useFuego hook to see all the available arguments for config and options.
- *
- * @returns { data: room, loading, error, ref, create, edit, usersAreTyping, namesOfUsersTyping } data is formatted for rendering room.
- */
-export default _default;

package/lib/typescript/hooks/useRoom/types.d.ts

@@ -1,5 +0,0 @@
-import { FuegoQueryConfig } from '@nandorojo/fuego/lib/typescript/FuegoQuery/types';
-export interface UseRoomType extends Omit<FuegoQueryConfig, 'path'> {
-    id: string;
-    listen?: boolean;
-}

package/lib/typescript/hooks/useSend/useSendToGroup/index.d.ts

@@ -1,6 +0,0 @@
-import { NewMessageModel } from '../../../classes/Message/types';
-export default function <MessageModel extends NewMessageModel>(): {
-    send: (message: MessageModel, recipients: string[]) => void;
-    uploading: boolean;
-    error: null;
-};

package/lib/typescript/hooks/useSend/useSendToPeople/index.d.ts

@@ -1,6 +0,0 @@
-import { NewMessageModel } from '../../../classes/Message/types';
-export default function <MessageModel extends NewMessageModel>(): {
-    send: (message: MessageModel, recipients: string[]) => void;
-    uploading: boolean;
-    error: null;
-};

package/lib/typescript/hooks/useTyping/index.d.ts

@@ -1,36 +0,0 @@
-declare const _default: ({ roomId, text, delay }: {
-    roomId: string;
-    text: string;
-    delay?: number | null | undefined;
-}) => void;
-/**
- * useTyping automatically updates the backend whenever a user is typing.
- *
- * @param options - A dictionary to configure the typing.
- * @param options.roomId - **Required** unique id of the room you're typing in.
- * @param options.text - **Required** The current text state of your chat input
- * @param options.delay (Optional) Set the timeout delay to mark typing false. Set null if you don't want a time out.
- *
- * @example
- * ```javascript
- * // input text state
- * const [text, setText] = useState('')
- * // let's say we're getting our room id from our react-navigation params
- * const navigation = useNavigation()
- * const roomId = navigation.params.id
- *
- * useTyping({ roomId, text })
- *
- * <ChatComponent text={text} onChangeText={setText} />
- * ```
- *
- * @returns
- * Doesn't return anything. We live in an undefined world, I suppose.
- *
- * @remarks
- * The actual data of who is typing is stored in the chatroom object.
- * If you want to get this data realtime in a room, consider using useRoom({ listen: true }). This data will also be in useInbox().
- * See docs for useRoom or useInbox for more.
- *
- */
-export default _default;

package/lib/typescript/hooks/useViewMessages/index.d.ts

@@ -1,18 +0,0 @@
-import { NewMessageModel } from '../../classes/Message/types';
-import { UseViewMessagesConfig, UseViewMessagesMethods } from './types';
-/**
- * React hook that returns a function useful for marking messages as viewed on the backend.
- * It works by only clearing unread count when you've reached the most recent message, leveraging React Native FlatList's onViewableItemsChanged.
- * This is only useful if you're using the Juice chat backend.
- *
- * @example
- * ```js
- * const onViewMessages = useViewMessages({ roomId: 'some_chat_room_id' })
- *
- * return <Juice.Chat onViewMessages={onViewMessages} />
- * ```
- */
-export default function <Model extends NewMessageModel = NewMessageModel>(config: UseViewMessagesConfig, methods?: UseViewMessagesMethods<Model>): ({ visibleMessages, latestMessageId }: {
-    visibleMessages: Model[] | null;
-    latestMessageId: string | null;
-}) => void;

package/lib/typescript/hooks/useViewMessages/types.d.ts

@@ -1,20 +0,0 @@
-import { NewMessageModel } from '../../classes/Message/types';
-export interface UseViewMessagesConfig {
-    roomId: string;
-}
-/**
- * An optional dictionary for using custom callbacks for viewed messages.
- */
-export interface UseViewMessagesMethods<Model extends NewMessageModel = NewMessageModel> {
-    /**
-     * Callback function that is triggered whenever the messages in view changes.
-     * Since the `useViewMessages` hook is only concerned with updating a chat room's unread count and such, `onViewMessages` might be useful if you want to have your own analytics or message tracking.
-     *
-     * @param info - A dictionary containing info about the currently visible messages
-     * @param info.visibleMessages - An array of messages that are currently in view
-     *
-     */
-    onViewMessages?: (info: {
-        visibleMessages: Model[];
-    }) => void;
-}

package/lib/typescript/index.d.ts

@@ -1,11 +0,0 @@
-export * from './components';
-export * from './classes';
-export * from './hooks';
-import * as ChatType from './components/Chat/types';
-import * as InboxType from './components/Inbox/types';
-import * as MessageType from './classes/Message/types';
-import * as RoomType from './classes/Room/types';
-export declare const ChatTypes: typeof ChatType;
-export declare const InboxTypes: typeof InboxType;
-export declare const MessageTypes: typeof MessageType;
-export declare const RoomTypes: typeof RoomType;

package/src/ChatContext/index.tsx

@@ -1,9 +0,0 @@
-import { createContext } from 'react'
-import { ChatContextType } from './types'
-
-// no default necessary with a provider at the top
-// @ts-ignore
-const context = createContext<ChatContextType>()
-context.displayName = 'ChatJS'
-
-export default context

package/src/ChatContext/types.ts

@@ -1,4 +0,0 @@
-export interface ChatContextType {
-	userId: string
-	authToken: string
-}

package/src/classes/Chat/index.ts

@@ -1,46 +0,0 @@
-import { ChatConfig } from './types'
-
-export default class Chat {
-	private chat: ChatConfig
-	constructor(chat: ChatConfig = {}) {
-		this.chat = chat
-		// this.chat = {
-		// 	...chat,
-		// 	httpCallables: {
-		// 		sendMessageFromFeed: 'sendMessageFromFeed',
-		// 		sendMessageToPeople: 'sendToPeople',
-		// 		sendMessageToGroup: 'sendToGroup',
-		// 		...(chat.httpCallables || {})
-		// 	}
-		// }
-	}
-	get roomsCollection() {
-		return this.chat.roomsCollection || 'rooms'
-	}
-	get messagesCollection() {
-		return this.chat.messagesCollection || 'messages'
-	}
-	get httpCallables() {
-		return {
-			sendMessageFromFeed:
-				(this.chat.httpCallables &&
-					this.chat.httpCallables.sendMessageFromFeed) ||
-				'sendMessageFromFeed',
-			sendMessageToPeople:
-				(this.chat.httpCallables &&
-					this.chat.httpCallables.sendMessageToPeople) ||
-				'sendMessageToPeople',
-			sendMessageToGroup:
-				(this.chat.httpCallables &&
-					this.chat.httpCallables.sendMessageToGroup) ||
-				'sendMessageToGroup',
-			createRoom:
-				(this.chat.httpCallables && this.chat.httpCallables.createRoom) ||
-				'createRoom',
-			sendMessageToRooms:
-				(this.chat.httpCallables &&
-					this.chat.httpCallables.sendMessageToRooms) ||
-				'sendMessageToRooms'
-		}
-	}
-}

package/src/classes/Chat/types.ts

@@ -1,23 +0,0 @@
-export type RoomPathFunc = (roomId: string) => string
-
-export interface ChatConfig {
-	roomsCollection?: string
-	messagesCollection?: string
-	httpCallables?: {
-		sendMessageFromFeed: string
-		sendMessageToPeople: string
-		sendMessageToGroup: string
-		sendMessageToRooms: string
-		createRoom: string
-	}
-}
-
-export interface ChatModel {
-	roomsCollection: string
-	messagesCollection: string
-	httpCallables: {
-		sendMessageFromFeed: string
-		sendMessageToPeople: string
-		sendMessageToGroup: string
-	}
-}

package/src/classes/Inbox/index.ts

@@ -1,12 +0,0 @@
-import { InboxModel } from './types'
-import { chat } from '../../components/ChatProvider'
-
-export default class {
-	private inbox: InboxModel
-	constructor(inbox: InboxModel) {
-		this.inbox = inbox
-	}
-	get path() {
-		return chat.messagesCollection
-	}
-}

package/src/classes/Inbox/types.ts

@@ -1,3 +0,0 @@
-import { ExistingRoomModel } from '../Room/types'
-
-export type InboxModel = ExistingRoomModel[]

package/src/classes/Message/index.ts

@@ -1,310 +0,0 @@
-import {
-	MessageModel,
-	EditMessageModel,
-	RoomId,
-	NewMessageModel,
-	MessageModelDocument,
-	SendFromFeedRecipients,
-	recipientHasId,
-	recipientHasMembers,
-	SendFromFeedModel,
-	isNewMessageModel,
-	NewMessageFormattedForServer
-} from './types'
-import { fuego, chat } from '../../components/ChatProvider/index'
-import Room from '../Room'
-import { LastMessageServer, RoomMembers, RoomMember } from '../Room/types'
-import { ReactionOption } from '../Reaction/types'
-
-export default class {
-	private message: MessageModel
-	constructor(message: MessageModel) {
-		this.message = message
-	}
-	/**
-	 * A function to send one message to many different existing rooms/group chats separately.
-	 *
-	 * @param recipients An array of rooms ids where this message will be sent to separately
-	 * @returns Promise that returns a room ID if there is only one (or promise that resolves as null if the message object isn't valid)
-	 */
-	async sendToRooms(recipients: string[]) {
-		try {
-			const send = fuego.firebase
-				.functions()
-				.httpsCallable(chat.httpCallables.sendMessageToRooms)
-			if (!isNewMessageModel(this.message)) {
-				throw new Error(
-					'FAILED TO SEND TO ROOMS: message object is not NewMessageModel'
-				)
-			}
-			this.message = {
-				...this.message,
-				createdAt: fuego.firebase.firestore.FieldValue.serverTimestamp()
-			} as NewMessageFormattedForServer
-			return send({
-				message: this.message,
-				recipients
-			})
-		} catch (e) {
-			console.error(e)
-			return {
-				data: null
-			}
-		}
-	}
-	/**
-	 * A function to send one message to many different people individually.
-	 * For each recipient, if a room for them doesn't exist, it will get created and the message will be added to it.
-	 * If the room does exist, the message will be added to it.
-	 *
-	 * @param recipients An array of user ids whom this message will be sent to separately
-	 * @returns Promise that returns a room ID (or promise that resolves as null if the message object isn't valid)
-	 */
-	async sendToPeople(recipients: string[]) {
-		const send = fuego.firebase
-			.functions()
-			.httpsCallable(chat.httpCallables.sendMessageToPeople)
-		try {
-			if (!isNewMessageModel(this.message)) {
-				throw new Error(
-					'FAILED TO SEND TO PEOPLE: message object is not NewMessageModel'
-				)
-			}
-			this.message = {
-				...this.message,
-				createdAt: fuego.firebase.firestore.FieldValue.serverTimestamp()
-			} as NewMessageFormattedForServer
-			return send({
-				message: this.message,
-				recipients
-			})
-		} catch (e) {
-			console.error(e)
-			return {
-				data: null
-			}
-		}
-	}
-	/**
-	 * Sends message to a group. This is useful when you don't have a room id but do have a list of people you want to send a message to. If you want to send the message to them separately, try sendToPeople instead.
-	 * This function will create a group chat with the specified users if one doesn't exist yet. If it does exist already, then it will add to that existing room.
-	 * @param recipients Array of uids for people in the group this message should send to.
-	 * @returns Promise that returns a room ID (or promise that resolves as null if the message object isn't valid)
-	 */
-	async sendToGroup(recipients: string[]) {
-		const send = fuego.firebase
-			.functions()
-			.httpsCallable(chat.httpCallables.sendMessageToGroup)
-		try {
-			if (!isNewMessageModel(this.message)) {
-				throw new Error(
-					'FAILED TO SEND TO PEOPLE: message object is not NewMessageModel'
-				)
-			}
-			this.message = {
-				...this.message,
-				createdAt: fuego.firebase.firestore.FieldValue.serverTimestamp()
-			} as NewMessageFormattedForServer
-			return send({
-				message: this.message,
-				recipients
-			})
-		} catch (e) {
-			console.error(e)
-			return {
-				data: null
-			}
-		}
-	}
-	/**
-	 *  deprecated: fuck this function
-	 */
-	sendFromFeed(to: SendFromFeedRecipients) {
-		const batch = fuego.db.batch()
-		const promises: Promise<firebase.functions.HttpsCallableResult>[] = []
-
-		// the to variable is an array of dictionaries
-		// the dictionaries can be EITHER { id: string } or { recipients: Array<recipient> }
-		// example:
-		// you might send a message to five different places
-		// could be 3 people, and 2 existing rooms
-		// this would be an array of 5 items, 3 with recipients, 2 with id
-		// example of the array:
-		// [
-		// 1) send to a room that has these two users
-		// { recipients: [{id: uid, name: username }, {uid: uid2, name: name2 }]},
-		// 2) send to an already existing room (likely pressing a group)
-		// { id: roomId },
-		// 3) send to one person, unaware if this room exists
-		// { recipients: [{id: uid, name: username }]},
-		// ]
-
-		// now, set of people we're sending this to...
-		to.forEach(room => {
-			const { id, ...message } = this.message as NewMessageModel
-			if (recipientHasId(room)) {
-				// if this recipient is a specified room, then send to that
-				const { messagesPath } = new Room({ id: room.id })
-				const ref = fuego.db.collection(messagesPath).doc(id)
-				batch.set(ref, message)
-			} else if (recipientHasMembers(room)) {
-				// otherwise, if you're just sending to a list of ambigious recipients...
-				// note: this list will often be one person you're choosing from a feed
-				// list could be: { recipients: [{ name: string, id: string }, { ...otherRecipient }]}
-				const peopleInThisRoomOtherThanMe = room.recipients
-					.slice()
-					.sort((a, b) => (a.id > b.id ? 1 : -1))
-				const addMessage = fuego.firebase
-					.functions()
-					.httpsCallable(chat.httpCallables.sendMessageFromFeed)
-				const newMessage: SendFromFeedModel = {
-					...(message as NewMessageModel),
-					recipients: peopleInThisRoomOtherThanMe
-				}
-				promises.push(addMessage(newMessage))
-			}
-		})
-
-		return Promise.all<any>([batch.commit(), ...promises])
-
-		// return {
-		// 	batch: () => batch.commit(),
-		// 	toRecipients: () => Promise.all(promises)
-		// }
-	}
-	/**
-	 * Send message by adding it directly to the backend
-	 * @param roomId The id of the room you want to send this to. Could also be an array of ids, if the same message should go to multiple rooms.
-	 */
-	send(roomId: RoomId) {
-		this.addToFirebase(roomId)
-	}
-	edit(roomId: string) {
-		return this.updateOnFirebase(roomId)
-	}
-	formatForRender(): NewMessageModel[] | NewMessageModel | null {
-		function isDocList(m: MessageModel): m is MessageModelDocument[] {
-			return !!(m as MessageModelDocument[])
-		}
-		function isDocument(m: MessageModel): m is MessageModelDocument {
-			return !!(m as MessageModelDocument)
-		}
-		try {
-			if (isDocList(this.message)) {
-				return (
-					(this.message as MessageModelDocument[]).map(
-						(doc: MessageModelDocument) => ({
-							...doc,
-							id: doc.id,
-							createdAt: doc.createdAt.toDate()
-						})
-					) || []
-				)
-			}
-			if (isDocument(this.message))
-				return {
-					...this.message,
-					id: this.message.id,
-					createdAt: this.message.createdAt.toDate()
-				}
-
-			throw new Error('Wrong model here.')
-		} catch (e) {
-			console.error(
-				'wrong model given to format for render in Message class.',
-				e
-			)
-			return null
-		}
-	}
-	formatForSend() {
-		try {
-			const isNew = (m: MessageModel): m is NewMessageModel[] =>
-				!!(m as NewMessageModel[])
-			if (isNew(this.message)) {
-				this.message = (this.message as NewMessageModel[]).map(message => ({
-					...message,
-					text: (message.text && message.text.trim()) || '',
-					createdAt: fuego.firebase.firestore.FieldValue.serverTimestamp()
-				})) as NewMessageFormattedForServer[]
-				return this
-			}
-			throw new Error('wrong format for formatting for send')
-		} catch (e) {
-			console.error(e)
-			return this
-		}
-	}
-	addToFirebase(roomId: RoomId) {
-		const { message: messages } = this
-
-		const batch = fuego.db.batch()
-
-		const updateBatch = (roomId: string) => {
-			// for each message, add to this batch...
-			const addToBatch = (message: NewMessageFormattedForServer) => {
-				try {
-					const { messagesPath, path: roomPath } = new Room({ id: roomId })
-					const ref = fuego.db.collection(messagesPath).doc(message.id)
-
-					// remove id from message for single source of truth
-					// it'll be put back again upon format()-ing
-					const { id, ...messageDoc } = message
-					batch.set(ref, messageDoc)
-
-					// update the latest message
-					const { displayName, uid } = fuego.auth().currentUser as firebase.User
-					const roomRef = fuego.db.doc(roomPath)
-					const lastMessage: LastMessageServer = {
-						name: displayName || 'Name failed',
-						id: uid,
-						system: false,
-						text: message.text,
-						createdAt: message.createdAt
-					}
-					batch.update(roomRef, { lastMessage })
-				} catch (e) {
-					console.error('sending message had an error:', e)
-				}
-			}
-			;(messages as NewMessageFormattedForServer[]).forEach(addToBatch)
-		}
-
-		// if you're sending these message(s) to multiple rooms, loop through each room...
-		if (Array.isArray(roomId)) {
-			;(roomId as string[]).forEach(updateBatch)
-		} else {
-			// just send to this room
-			updateBatch(roomId as string)
-		}
-		// once everything has been added to the db batch, commit it
-		return batch.commit()
-	}
-	updateOnFirebase(roomId: string) {
-		const { path } = new Room({ id: roomId })
-		const { id, ...message } = this.message as EditMessageModel
-		return fuego.db
-			.collection(path)
-			.doc((this.message as EditMessageModel).id)
-			.set(message, { merge: true })
-	}
-	// TODO get members through some other method...idk
-	// eek. what a mess.
-	getUsersWhoReacted(
-		reaction: ReactionOption,
-		{ roomMembers }: { roomMembers: RoomMembers }
-	): RoomMember[] {
-		const users: RoomMember[] = []
-		if (!isNewMessageModel(this.message)) {
-			console.warn(
-				'error getting users who reacted. Needs the new message model passed as an argument, but instead it got this:',
-				this.message
-			)
-		} else if (this.message.reactions) {
-			this.message.reactions[reaction].forEach(
-				uid => roomMembers[uid] && users.push(roomMembers[uid])
-			)
-		}
-		return users
-	}
-}