chat 1.0.8 → 4.0.0

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
-	}
-}

package/src/classes/Message/types.ts

@@ -1,118 +0,0 @@
-import { FieldValue } from '@firebase/firestore-types'
-import { ReactionOption } from '../Reaction/types'
-
-export interface Message {
-	id: string
-	// roomId: string
-}
-
-export interface NewMessageModel extends Omit<Message, 'roomId'> {
-	text: string
-	createdAt: Date
-	user: {
-		id: string
-		name: string
-		avatar: string
-	}
-	// image?: string
-	// // You can also add a video prop:
-	// video?: string
-	system?: boolean
-	media?: MessageMedia
-	reactions?: {
-		[option in ReactionOption]: string[]
-	}
-	// Any additional custom parameters are passed through
-}
-
-export interface MessageMediaWithUrl {
-	url: string
-	uri?: string
-	height: number
-	width: number
-	contentType: 'video' | 'image'
-}
-
-export interface MessageMediaWithUri {
-	url: string
-	uri?: string
-	height: number
-	width: number
-	contentType: 'video' | 'image'
-}
-
-export type MessageMedia = MessageMediaWithUrl | MessageMediaWithUri
-
-// export interface MessageMedia {
-// 	url?: string
-// 	uri: string
-// 	height: number
-// 	width: number
-// 	contentType: 'video' | 'image'
-// }
-
-export interface NewMessageFormattedForServer
-	extends Omit<NewMessageModel, 'createdAt'> {
-	createdAt: FieldValue
-}
-
-export function isNewMessageModel(
-	message: MessageModel
-): message is NewMessageModel {
-	return !!(message as NewMessageModel)
-}
-
-export function isNewMessageFormattedForServer(
-	message: MessageModel
-): message is NewMessageFormattedForServer {
-	return !!(message as NewMessageFormattedForServer)
-}
-
-export interface EditMessageModel extends Message {
-	text?: string
-}
-
-export type SendToRecipients = string[]
-
-// you might send a message to multiple rooms
-export type RoomId = string | string[]
-
-// the message model can be one of them
-export type MessageModel =
-	| Message
-	| NewMessageModel[]
-	| EditMessageModel
-	| MessageModelDocument[]
-	| NewMessageFormattedForServer[]
-	| NewMessageFormattedForServer
-
-export interface MessageModelDocument
-	extends Omit<NewMessageModel, 'createdAt'> {
-	id: string
-	createdAt: firebase.firestore.Timestamp
-}
-
-export type SendFromFeedRecipient =
-	| {
-			id: string // roomId
-	  }
-	| SendFromFeedRecipientArray
-
-export interface SendFromFeedRecipientArray {
-	recipients: { id: string; name: string }[]
-}
-
-export const recipientHasId = (
-	recipient: SendFromFeedRecipient
-): recipient is { id: string } => !!(recipient as { id: string })
-
-export const recipientHasMembers = (
-	recipient: SendFromFeedRecipient
-): recipient is SendFromFeedRecipientArray =>
-	!!(recipient as SendFromFeedRecipientArray)
-
-export type SendFromFeedRecipients = SendFromFeedRecipient[]
-
-export interface SendFromFeedModel extends Omit<NewMessageModel, 'id'> {
-	recipients: SendFromFeedRecipientArray['recipients']
-}

package/src/classes/Reaction/index.ts

@@ -1,108 +0,0 @@
-import { ReactionConfig } from './types'
-import Room from '../Room'
-import { fuego } from '../../components/ChatProvider'
-import { LastMessageServer } from '../Room/types'
-
-export default class {
-	private config: ReactionConfig
-	constructor(config: ReactionConfig) {
-		this.config = config
-	}
-	get path() {
-		const { messagesPath } = new Room({ id: this.config.roomId })
-		return `${messagesPath}/${this.config.messageId}`
-	}
-	verb(): { add: string; remove: string } {
-		switch (this.config.reaction) {
-			case 'like':
-				return { add: 'liked', remove: 'unliked' }
-			case 'love':
-				return { add: 'loved', remove: 'unloved' }
-			default: {
-				console.warn(
-					'reaction type is not valid. see reaction class:',
-					this.config.reaction
-				)
-				return { add: '', remove: '' }
-			}
-		}
-	}
-	async add() {
-		const { uid } = fuego.auth().currentUser as firebase.User
-		const batch = fuego.db.batch()
-		const messageRef = fuego.db.doc(this.path)
-		batch.update(messageRef, {
-			[`reactions.${this.config.reaction}`]: fuego.firebase.firestore.FieldValue.arrayUnion(
-				uid
-			)
-		})
-		const { path: roomPath } = new Room({ id: this.config.roomId })
-		const roomRef = fuego.db.doc(roomPath)
-
-		batch.update(roomRef, {
-			lastMessage: this.makeLastMessage({ remove: false })
-		})
-		return batch.commit()
-	}
-	async remove() {
-		const { uid } = fuego.auth().currentUser as firebase.User
-		const batch = fuego.db.batch()
-		const messageRef = fuego.db.doc(this.path)
-		batch.update(messageRef, {
-			[`reactions.${this.config.reaction}`]: fuego.firebase.firestore.FieldValue.arrayRemove(
-				uid
-			)
-		})
-		const { path: roomPath } = new Room({ id: this.config.roomId })
-		const roomRef = fuego.db.doc(roomPath)
-
-		batch.update(roomRef, {
-			lastMessage: this.makeLastMessage({ remove: true })
-		})
-		return batch.commit()
-	}
-	makeReactionDescriptionText(remove?: boolean): string {
-		if (this.config.descriptionText === null) return ''
-		const { displayName } = fuego.auth().currentUser as firebase.User
-		const { myName } = this.config
-		const name = myName || displayName || ''
-		const verb = remove ? this.verb().remove : this.verb().add
-		if (this.config.descriptionText) {
-			if (typeof this.config.descriptionText === 'string')
-				return this.config.descriptionText
-			if (typeof this.config.descriptionText !== 'function') {
-				console.error(
-					'🍇 Juice Reaction error. The descriptionText property should be either 1) a string or 2) a function that returns a string. Instead, you passed',
-					this.config.descriptionText,
-					' of type ',
-					typeof this.config.descriptionText,
-					'. See the docs or command+hover over the descriptionText property in VS Code to details.'
-				)
-			} else {
-				return this.config.descriptionText({
-					reaction: this.config.reaction,
-					name: name || '',
-					text: this.config.text,
-					verb,
-					remove: !!remove
-				})
-			}
-		}
-		const firstName = name && name.split(' ')[0]
-		let text = `${firstName} ${verb} a message`
-		if (this.config.text) {
-			text = `${firstName} ${verb} "${this.config.text}"`
-		}
-		return text
-	}
-	makeLastMessage(options: { remove?: boolean }): LastMessageServer {
-		const { displayName: name = '' } = fuego.auth().currentUser as firebase.User
-		return {
-			id: '',
-			createdAt: fuego.firebase.firestore.FieldValue.serverTimestamp(),
-			name: name || '',
-			system: true,
-			text: this.makeReactionDescriptionText(options.remove)
-		}
-	}
-}

package/src/classes/Reaction/types.ts

@@ -1,37 +0,0 @@
-export interface ReactionConfig {
-	myName?: string
-	messageId: string
-	roomId: string
-	text: string
-	reaction: ReactionOption
-	/**
-	 * An **optional** string or pure function to override the default description text.
-	 * The description text is used to create the last message that shows up in the inbox.
-	 *
-	 * By default, this will look something like: <name> <reaction>d "<message text>". For instance: Fernando liked "I want a pair of PATOS Shoes."
-	 *
-	 * If `null`, text will be an empty string.
-	 *
-	 * A verb for like will be 'liked', and if it's a removal, then it's 'unlike'. This pattern follows for other reactions too.
-	 *
-	 * @example
-	 * ```js
-	 * const reaction = new Reaction({
-	 * descriptionText: ({ reaction, name, text, verb, remove }) => remove ? \`${name} happily ${verb} ${text}\` : \`${name} sadly ${verb} ${text}\`,
-	 * text: message.text, roomId: room.id, messageId: message.id, text: message.text
-	 * })
-	 * ```
-	 */
-	descriptionText?:
-		| null
-		| string
-		| ((info: {
-				reaction: ReactionOption
-				name: string
-				text: string
-				verb: string
-				remove: boolean
-		  }) => string)
-}
-
-export type ReactionOption = 'like' | 'love'