diff --git a/.gitignore b/.gitignore index 97aca2e..819f592 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,29 @@ -.env -node_modules \ No newline at end of file +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +.DS_Store + +# Generated by package manager +node_modules/ + +# Generated by Cordova +/plugins/ +/platforms/ + +pandora.apks +/android/app/build/ +test-upload-key.jks diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 0000000..e69de29 diff --git a/README.md b/README.md new file mode 100644 index 0000000..f310aab --- /dev/null +++ b/README.md @@ -0,0 +1,48 @@ +PANDORA + +Pandora is an open-source web client for the WAHA API. + +## Features +- [x] Contact list1 +- [x] Chat screen2 +- [x] Sending messages +- [ ] Sending polls +- [X] Receiving messages (WebSocket)3 +- [ ] Receiving polls +- [ ] Answering polls +- [ ] Sending audio messages +- [x] Sending attachments (sends image/video as such)4 +- [x] Notification sound5 +- [ ] Browser notification +- [x] Download attachments +- [x] Automatically download images6 +- [X] Local message storing +- [ ] Message encryption +- [ ] Light theme +- [X] Custom wallpaper + +1. Does not show contact name in any engine other than WEBJS +2. Loads the last 40 messages +3. Will not contain contact name in groups if you're in any engine other than WEBJS +4. You will receive a duplicate of your attachment in any engine other than WEBJS +5. Allow autoplay to avoid blocking +6. Only on WEBJS engine + +## Setup +1. Check [WAHA Docs](https://waha.devlike.pro/docs/) to setup WAHA +2. Serve Pandora in any HTTP server. The GitHub Pages for this repository will only work for WAHA servers over HTTPS (due to mixed content) +3. It works better with WEBJS engine. +4. Access Pandora and change the server address, session and API key to match your server +5. You should probably be good to go + +## Frequently Asked Questions + +### Why? +Because WhatsApp won't run on my LineageOS. Seems like the APK from WhatsApp's own website doesn't count official. +Sadly there are places in the world where you need this bullshit application to be a functional human being. + +### Will this get me banned? +It's against WhatsApp TOS, though it mocks message typing and should not be able to be identified so easily. I haven't got myself nor heard anyone getting in trouble for using WAHA correctly. + +### How it works +Pure magic. (Mocks a WhatsApp Web session) diff --git a/fonts/selawk.ttf b/fonts/selawk.ttf new file mode 100644 index 0000000..736bac3 Binary files /dev/null and b/fonts/selawk.ttf differ diff --git a/fonts/selawkb.ttf b/fonts/selawkb.ttf new file mode 100644 index 0000000..2134a76 Binary files /dev/null and b/fonts/selawkb.ttf differ diff --git a/fonts/selawkl.ttf b/fonts/selawkl.ttf new file mode 100644 index 0000000..cbfaaf9 Binary files /dev/null and b/fonts/selawkl.ttf differ diff --git a/fonts/selawksb.ttf b/fonts/selawksb.ttf new file mode 100644 index 0000000..5ec501d Binary files /dev/null and b/fonts/selawksb.ttf differ diff --git a/fonts/selawksl.ttf b/fonts/selawksl.ttf new file mode 100644 index 0000000..bc3fa08 Binary files /dev/null and b/fonts/selawksl.ttf differ diff --git a/icon-192.png b/icon-192.png new file mode 100644 index 0000000..1aa462a Binary files /dev/null and b/icon-192.png differ diff --git a/icon-512.png b/icon-512.png new file mode 100644 index 0000000..06df20e Binary files /dev/null and b/icon-512.png differ diff --git a/index.html b/index.html new file mode 100644 index 0000000..1f455f7 --- /dev/null +++ b/index.html @@ -0,0 +1,173 @@ + + + + + + + Pandora + + + + + + + + + +
+ + + + + +
+ +
+ +
+
+
+
+

Select a contact to view the conversation or start a new chat.

+
+
+ + + +
+
+ +
+

Pandora User

+
+ +
+

Pandora User

+ +
+
+
+ +
+
+
+

SETTINGS

+
+
+

server

+
+ + +
+
+ + +
+
+ + +
+

Note: Requests are sent directly from your browser to the WAHA server. Make sure CORS is enabled on your WAHA instance.

+

chats

+
+ + +
+
+ + +
+
+
+ +
+
+
+ + Backend connected +
+
+
+
+
+ + + + + diff --git a/index.js b/index.js deleted file mode 100644 index a9ede1b..0000000 --- a/index.js +++ /dev/null @@ -1,21 +0,0 @@ -import express from "express"; -import path from "path"; -import { fileURLToPath } from "url"; - -const app = express(); -const PORT = process.env.PORT || 3100; - -// Resolve __dirname in ES modules -const __filename = fileURLToPath(import.meta.url); -const __dirname = path.dirname(__filename); - -// Serve static assets from the public folder -app.use(express.static(path.join(__dirname, "public"))); - -// Start static file server -app.listen(PORT, () => { - console.log(`==================================================`); - console.log(` Pandora Chat Static Server is running!`); - console.log(` URL: http://localhost:${PORT}`); - console.log(`==================================================`); -}); \ No newline at end of file diff --git a/js/app.js b/js/app.js new file mode 100644 index 0000000..1611b35 --- /dev/null +++ b/js/app.js @@ -0,0 +1,451 @@ +import { config } from "./config.js"; +import { waha } from "./waha.js"; +import { ui, elements } from "./ui.js"; +import { websocket } from "./websocket.js"; +import { compensateMessageOrdering, debounce, formatTime, normalizeId } from "./utils.js"; +import { fetchChats, getAppUser, getChatMessages, getChatPicture, getChats, getUser, getUserAbout, sendStatus, updateOnlineStatus } from "./storage.js"; +import { upsertMessages } from "./db.js"; + +let activeChatState = null; +const messageTone = new Audio("./message.ogg"); +const longPressEvent = new CustomEvent("longpress"); +export let isLoadingChat = false; + +document.addEventListener('DOMContentLoaded', async () => { + elements.inputApiKey.value = config.apiKey; + elements.inputWahaUrl.value = config.wahaUrl; + elements.inputSession.value = config.session; + elements.inputBackgroundImage.value = config.bgImg; + elements.inputBackgroundOpacity.value = config.bgOpacity; + elements.activeChatContainer.style.setProperty('--background-image', `URL("${config.bgImg}")`); + elements.activeChatContainer.style.setProperty('--background-opacity', `${config.bgOpacity}`); + await updateOnlineStatus(); + setupEventListeners(); + try { + setupElementsData(); + loadChats(); + checkWahaStatus(); + initWebSocket(); + } finally { + elements.chatsLoader.classList.add('hidden'); + } +}); + +async function setupElementsData() { + const usr = await getAppUser(); + const usrPic = (await getChatPicture(usr.id))?.url; + const usrInfo = await getUser(usr.id); + const usrAbout = (await getUserAbout(usr.id)).about; + elements.contentUserName.forEach(e => { + e.innerHTML = usr.pushName; + }) + elements.contentUserNumber.forEach(async e => { + e.innerHTML = usrInfo.number; + }) + elements.resourceUserPic.forEach(async e => { + e.src = usrPic; + }) + elements.valueUserStatus.forEach(async e => { + e.value = usrAbout.trim(); + }) +} + +function loadChats() { + elements.chatsLoader.classList.remove('hidden'); + try { + fetchChats().then(async () => { + ui.renderChatList(getChats(), activeChatState, selectChat); + + const hash = window.location.hash; + if (hash && hash.startsWith('#chat-')) { + const chatId = hash.replace('#chat-', ''); + const chat = getChats().find(c => c.id === chatId); + if (chat) { + selectChat(chat, true, false); + } + } + }); + } catch (error) { + console.error('Failed to load chats:', error); + elements.chatList.innerHTML = ` +
  • +

    Connection to WAHA failed.

    +

    + Ensure WAHA server is running and CORS is enabled, or click Settings to configure. +

    +

    ${error.message}

    +
    • + `; + } finally { + elements.chatsLoader.classList.add('hidden'); + } +} + +let isScrollingProgrammatically = false; +let scrollTimeout = null; + +function scrollToChat(smooth = true) { + isScrollingProgrammatically = true; + elements.appContainer.scrollTo({ + left: elements.appContainer.clientWidth, + behavior: smooth ? 'smooth' : 'auto' + }); + setTimeout(() => { isScrollingProgrammatically = false; }, smooth ? 400 : 50); +} + +function scrollToList(smooth = true) { + isScrollingProgrammatically = true; + elements.appContainer.scrollTo({ + left: 0, + behavior: smooth ? 'smooth' : 'auto' + }); + setTimeout(() => { isScrollingProgrammatically = false; }, smooth ? 400 : 50); +} + +function setupEventListeners() { + if (!window.location.hash) { + window.location.hash = ''; + } + + window.addEventListener('hashchange', () => { + const hash = window.location.hash; + if (hash && hash.startsWith('#chat-')) { + const chatId = hash.replace('#chat-', ''); + const chat = getChats().find(c => c.id === chatId); + if (chat) { + selectChat(chat, true); + } + } else { + closeActiveChat(true); + } + }); + + elements.appContainer.addEventListener('scroll', () => { + if (window.innerWidth > 768) return; + if (isScrollingProgrammatically) return; + + clearTimeout(scrollTimeout); + scrollTimeout = setTimeout(() => { + const scrollLeft = elements.appContainer.scrollLeft; + const width = elements.appContainer.clientWidth; + + if (scrollLeft < width * 0.2) { + // User swiped back to the list view + if (activeChatState) { + closeActiveChat(false); + } + } + }, 100); + }); + + document.addEventListener('keydown', (e) => { + if (e.code == "Escape") { + e.preventDefault(); + closeActiveChat(false); + } + }); + + elements.chatSearch.addEventListener('input', (e) => { + const query = e.target.value.toLowerCase(); + const filtered = getChats().filter(chat => + chat.name.toLowerCase().includes(query) + ); + ui.renderChatList(filtered, activeChatState, selectChat); + }); + + elements.messageForm.addEventListener('submit', (e) => { + e.preventDefault(); + sendMessage(); + }); + + elements.chatBottomBar.style.height = `${elements.chatInputPanel.offsetHeight}px`; + const observer = new ResizeObserver(() => { + elements.chatBottomBar.style.height = + `${elements.chatInputPanel.offsetHeight}px`; + }); + + observer.observe(elements.chatInputPanel); + elements.chatBottomBarBtn.addEventListener('click', ui.toggleChatBottomBar); + elements.chatBottomBar.addEventListener('click', (e) => { + if (e.target == e.currentTarget) ui.toggleChatBottomBar(); + }); + + elements.attachmentBtn.addEventListener('click', () => { + elements.attachmentInput.click(); + }) + elements.attachmentInput.addEventListener('change', function () { + const firstFile = this.files[0]; + sendFileMessage(firstFile); + }) + + elements.backToSidebarBtn.addEventListener('click', () => { + closeActiveChat(false); + }); + + elements.desktopSidebarButtons.forEach(sidebarBtn => { + sidebarBtn.addEventListener('click', () => { + ui.showExtraPage(sidebarBtn.dataset.page); + }) + }) + + elements.saveSettingsBtn.addEventListener('click', saveSettings); + + elements.inputUserStatus.addEventListener('input', debounce(async function() { + const result = await sendStatus(elements.inputUserStatus.value); + console.log(result); + }, 2000)) + + elements.selectable.forEach(e => { + let timerId, longPressed; + + e.addEventListener('mousedown', () => { + longPressed = false; + + timerId = setTimeout(() => { + longPressed = true; + e.dispatchEvent(longPressEvent); + }) + }) + + e.addEventListener('click', () => { + if (longPressed) { + e.preventDefault(); + clearTimeout(timerId); + } + }) + + e.addEventListener('mouseleave', () => { + clearTimeout(timerId); + }) + }) +} + +function initWebSocket() { + websocket.connect((data) => { + // console.log('[WS] Received event:', data.event, data); + const ev = data.event; + if (ev === 'message' || ev === 'message.any' || ev === 'message.ack') { + handleIncomingMessage(data.payload); + upsertMessages([data.payload]); + } + }); +} + + +async function handleIncomingMessage(msg) { + if (!msg) return; + + ui.updateChatInChatList(msg); + + const rawChatId = msg.chatId || msg.from || (msg.chat && msg.chat.id); + const msgChatId = normalizeId(rawChatId); + if (!msgChatId) { + console.warn('[WS] Could not resolve chatId from payload:', msg); + return; + } + + // console.log('[WS] Resolved msgChatId:', msgChatId, '| activeChatState:', activeChatState?.id); + if (!msg.fromMe) { + messageTone.play(); + } + + if (activeChatState && activeChatState.id === msgChatId) { + const msgId = normalizeId(msg.id) || msg.id; + const exists = document.getElementById(msgId); + if (!exists) { + const scrolled = elements.messagesContainer.scrollTop == elements.messagesContainer.scrollTopMax; + ui.appendSingleMessage({ ...msg, chatId: msgChatId }, activeChatState.name, (await getAppUser()).id); + if (scrolled) { + ui.scrollToBottom(); + } + } + } +} + +async function selectChat(chat, isPopState = false, smoothScroll = true) { + if (isLoadingChat) return; + + isLoadingChat = true; + activeChatState = chat; + + chat.unreadCount = 0; + + // ui.renderChatList(chatsState, activeChatState, selectChat); + + ui.toggleChatState(true); + elements.activeChatName.textContent = chat.name.toUpperCase(); + elements.activeChatAvatar.textContent = chat.name ? chat.name.substring(0, 1).toUpperCase() : '?'; + + elements.messagesContainer.innerHTML = ` +
    +
    +

    +
    +
    +
    +
    +
    +
    +
    `; + + elements.appContainer.classList.remove('no-active-chat'); + + if (window.innerWidth <= 768) { + scrollToChat(smoothScroll); + } + + if (!isPopState && window.location.hash !== `#chat-${chat.id}`) { + window.location.hash = ``; + window.location.hash = `chat-${chat.id}`; + } + + try { + const rawMessages = await getChatMessages(chat.id); + const processedMessages = compensateMessageOrdering(rawMessages); + ui.renderMessages(processedMessages, chat.name, (await getAppUser()).id, chat.id); + } catch (error) { + console.error('Failed to load messages:', error); + elements.messagesContainer.innerHTML = '
    Error loading messages
    '; + } + + isLoadingChat = false; +} + +async function closeActiveChat(isPopState = false) { + activeChatState = null; + + if (window.innerWidth <= 768) { + scrollToList(); + } else { + ui.toggleChatState(false); + } + + + if (!isPopState) { + if (window.location.hash.startsWith('#chat-')) { + history.back(); + } + } +} + +async function sendMessage() { + const text = elements.messageInput.value.trim(); + if (!text || !activeChatState) return; + + elements.messageInput.value = ''; + + const tempMsg = { + id: 'temp-' + Date.now(), + body: text, + fromMe: true, + sender: 'me', + timestamp: new Date().toISOString(), + status: 'sending' + }; + + ui.appendSingleMessage(tempMsg, activeChatState.name, (await getAppUser()).id); + ui.scrollToBottom(); + + try { + try { + await waha.startTyping(activeChatState.id); + const delay = Math.min(4000, Math.max(1000, text.length * 50)); + await new Promise(resolve => setTimeout(resolve, delay)); + } catch (e) { + console.warn('Presence start failed:', e); + } + + try { + await waha.stopTyping(activeChatState.id); + } catch (e) { + console.warn('Presence stop failed:', e); + } + + try { + if (!activeChatState.id.endsWith('@lid')) { + await waha.readChat(activeChatState.id); + } + } catch (e) { + console.warn('readChat failed (non-fatal):', e.message); + } + + const responseData = await waha.sendTextMessage(activeChatState.id, text); + + const tempBubble = document.getElementById(tempMsg.id); + if (tempBubble) { + if (responseData && responseData.id) { + tempBubble.id = normalizeId(responseData.id); + } + const meta = tempBubble.querySelector('.message-meta'); + meta.innerHTML = `${formatTime(new Date())}`; + } + + activeChatState.lastMessage = text; + activeChatState.timestamp = new Date(); + } catch (error) { + console.error('Failed to send message:', error); + const tempBubble = document.getElementById(tempMsg.id); + if (tempBubble) { + const meta = tempBubble.querySelector('.message-meta'); + meta.innerHTML = `Failed to send`; + } + } +} + +async function sendFileMessage(file) { + try { + const tempId = 'temp-' + Date.now(); + const tempMsg = { + _data: { + mimetype: file.type + }, + id: tempId, + body: "", + fromMe: true, + sender: 'me', + timestamp: new Date().toISOString(), + status: 'sending', + hasMedia: true, + media: { + url: URL.createObjectURL(file), + filename: file.name + } + }; + + ui.appendSingleMessage(tempMsg, activeChatState.name, (await getAppUser()).id, activeChatState.id, true); + ui.scrollToBottom(); + + const result = await waha.sendFileMessage(activeChatState.id, file); + ui.removeChatMessage(tempId); + ui.appendSingleMessage(result.id, activeChatState.name, (await getAppUser()).id, activeChatState.id); + } catch (error) { + console.error(error.message); + } +} + +function saveSettings() { + config.save( + elements.inputWahaUrl.value, + elements.inputSession.value, + elements.inputApiKey.value, + elements.inputBackgroundImage.value, + elements.inputBackgroundOpacity.value + ); + location.reload(); + loadChats(); + checkWahaStatus(); + initWebSocket(); +} + +async function checkWahaStatus() { + try { + const data = await waha.getVersion(); + ui.updateConnectionStatus(true, `WAHA Connected: v${data.version || 'OK'}`); + } catch (e) { + ui.updateConnectionStatus(false, 'WAHA Server Offline'); + } +} + +export function getCurrentChat() { + return activeChatState; +} \ No newline at end of file diff --git a/public/config.js b/js/config.js similarity index 62% rename from public/config.js rename to js/config.js index a571dbb..edb15f6 100644 --- a/public/config.js +++ b/js/config.js @@ -4,14 +4,20 @@ export const config = { wahaUrl: localStorage.getItem('waha_url') || 'http://inspiran.beetal-castor.ts.net:3100', session: localStorage.getItem('waha_session') || 'session_01kxc62bk5fs8vh4v127k88a7j', apiKey: localStorage.getItem('waha_api_key') || '', + bgImg: localStorage.getItem('background_image') || '', + bgOpacity: localStorage.getItem('background_opacity') || '0.4', - save(url, session, apiKey) { + save(url, session, apiKey, bgImg, bgOpacity) { this.wahaUrl = url.trim().replace(/\/$/, ""); this.session = session.trim(); this.apiKey = apiKey.trim(); + this.bgImg = bgImg.trim(); + this.bgOpacity = bgOpacity.trim(); localStorage.setItem('waha_url', this.wahaUrl); localStorage.setItem('waha_session', this.session); localStorage.setItem('waha_api_key', this.apiKey); + localStorage.setItem('background_image', this.bgImg); + localStorage.setItem('background_opacity', this.bgOpacity); } }; diff --git a/js/db.js b/js/db.js new file mode 100644 index 0000000..f1eb2a2 --- /dev/null +++ b/js/db.js @@ -0,0 +1,232 @@ +import { normalizeId } from "./utils.js"; + +const DB_NAME = "pandora"; +const DB_VERSION = 6; +let dbPromise = null; + +function openDb() { + if (dbPromise) return dbPromise; + + dbPromise = new Promise((resolve, reject) => { + const req = indexedDB.open(DB_NAME, DB_VERSION); + + req.onupgradeneeded = (e) => { + const db = req.result; + const tx = req.transaction; + + if (!db.objectStoreNames.contains("chats")) { + const store = db.createObjectStore("chats", { keyPath: "id" }); + store.createIndex("timestamp", "timestamp", { unique: false }); + } + + let msgStore; + if (!db.objectStoreNames.contains("messages")) { + msgStore = db.createObjectStore("messages", { keyPath: "id" }); + msgStore.createIndex("from", "from", { unique: false }); + msgStore.createIndex("fingerprint", ["from", "timestamp"], { unique: false }); + msgStore.createIndex("cidTimestampId", ["chatId", "timestamp", "id"], { unique: false }); + } else { + msgStore = tx.objectStore("messages"); + } + + if (!msgStore.indexNames.contains("chatId_timestamp")) { + msgStore.createIndex("chatId_timestamp", ["chatId", "timestamp"], { unique: false }); + } + + if (db.objectStoreNames.contains("messages")) { + msgStore.openCursor().onsuccess = (event) => { + const cursor = event.target.result; + if (cursor) { + const m = cursor.value; + const from = normalizeId(m.from); + const to = normalizeId(m.to); + const chatId = normalizeId(m.chatId) || (m.fromMe ? to : from); + if (!m.chatId && chatId) { + m.chatId = chatId; + cursor.update(m); + } + cursor.continue(); + } + }; + } + + if (!db.objectStoreNames.contains("media")) { + db.createObjectStore("media", { keyPath: "reqId" }); + } + }; + + req.onsuccess = () => resolve(req.result); + req.onerror = () => reject(req.error); + }); + + return dbPromise; +} + +export async function upsertChats(chats) { + const db = await openDb(); + + return new Promise((resolve, reject) => { + const tx = db.transaction("chats", "readwrite"); + const store = tx.objectStore("chats"); + + for (const c of chats) { + store.put({ + id: c.id, + name: c.name, + lastMessage: c.lastMessage, + timestamp: c.timestamp, + unreadCount: c.unreadCount ?? 0 + }); + } + + tx.oncomplete = () => resolve(); + tx.onerror = () => reject(tx.error); + }); +} + +export async function loadChatsSorted() { + const db = await openDb(); + + return new Promise((resolve, reject) => { + const tx = db.transaction("chats", "readonly"); + const store = tx.objectStore("chats"); + const idx = store.index("timestamp"); + + const result = []; + idx.openCursor(null, "prev").onsuccess = (e) => { + const cursor = e.target.result; + if (cursor) { + result.push(cursor.value); + cursor.continue(); + } else { + resolve(result); + } + }; + + tx.onerror = () => reject(tx.error); + }); +} + +function mapMessage(m) { + const from = normalizeId(m.from); + const to = normalizeId(m.to); + const chatId = normalizeId(m.chatId) || (m.fromMe ? to : from); + + return { + _data: m._data, + id: normalizeId(m.id), + timestamp: m.timestamp, + body: m.body, + from: from, + fromMe: m.fromMe, + ack: m.ack, + hasMedia: m.hasMedia, + media: m.media, + chatId: chatId, + } +} + +export async function upsertMessages(messages) { + const db = await openDb(); + + return new Promise((resolve, reject) => { + const tx = db.transaction("messages", "readwrite"); + const store = tx.objectStore("messages"); + + for (const m of messages) { + store.put(mapMessage(m)); + } + + tx.oncomplete = () => resolve(); + tx.onerror = () => reject(tx.error); + }); +} + +export async function loadLatestMessages(chatId, limit = 50) { + const db = await openDb(); + + return new Promise((resolve, reject) => { + const tx = db.transaction("messages", "readonly"); + const store = tx.objectStore("messages"); + const idx = store.index("chatId_timestamp"); + + const out = []; + + const range = IDBKeyRange.bound([chatId, -Infinity], [chatId, Infinity]); + + idx.openCursor(range, "prev").onsuccess = (e) => { + const cursor = e.target.result; + if (!cursor) return resolve(out); + + out.push(cursor.value); + if (out.length >= limit) resolve(out); + else cursor.continue(); + }; + + tx.onerror = () => reject(tx.error); + }); +} + +export async function loadOlderMessages(chatId, oldestTimestamp, oldestId, limit = 50) { + const db = await openDb(); + + return new Promise((resolve, reject) => { + const tx = db.transaction("messages", "readonly"); + const store = tx.objectStore("messages"); + const idx = store.index("cidTimestampId"); + + const out = []; + + const parsedTimestamp = isNaN(oldestTimestamp) ? oldestTimestamp : Number(oldestTimestamp); + + const range = IDBKeyRange.bound( + [chatId, -Infinity, ""], + [chatId, parsedTimestamp, oldestId], + false, + false + ); + + idx.openCursor(range, "prev").onsuccess = (e) => { + const cursor = e.target.result; + if (!cursor) return resolve(out); + + out.push(cursor.value); + + if (out.length >= limit) resolve(out); + else cursor.continue(); + }; + + tx.onerror = () => reject(tx.error); + }); +} + +export async function upsertMedia(reqId, blob, filename) { + const db = await openDb(); + + return new Promise((resolve, reject) => { + const tx = db.transaction("media", "readwrite"); + const store = tx.objectStore("media"); + + store.put({ + reqId: reqId, + blob: blob, + filename: filename + }); + + tx.oncomplete = () => resolve(); + tx.onerror = () => reject(tx.error); + }); +} + +export async function loadMedia(reqId) { + const db = await openDb(); + + return new Promise((resolve, reject) => { + const tx = db.transaction("media", "readonly"); + const store = tx.objectStore("media"); + const req = store.get(reqId); + + req.onsuccess = () => resolve(req.result); + req.onerror = () => reject(req.error); + }); +} \ No newline at end of file diff --git a/js/storage.js b/js/storage.js new file mode 100644 index 0000000..238b4b9 --- /dev/null +++ b/js/storage.js @@ -0,0 +1,150 @@ +import { loadChatsSorted, loadLatestMessages, loadMedia, loadOlderMessages, upsertChats, upsertMedia, upsertMessages } from "./db.js"; +import { waha } from "./waha.js"; + +let online = false; +let chats = []; + +export async function updateOnlineStatus() { + try { + await waha.getVersion(); + online = true; + } catch (error) { + console.log(error); + online = false; + } +} + +export async function fetchChats() { + if (online) { + await getRemoteChats() + } + chats = await loadChatsSorted(); +} + +export async function getRemoteChats() { + const u = await waha.getChats(); + + const mapped = u.map(chat => ({ + id: chat.id, + name: chat.name, + lastMessage: chat.lastMessage, + timestamp: chat.timestamp, + unreadCount: chat.unreadCount ?? 0 + })); + + await upsertChats(mapped); +} + +export function getUsers() { + return chats.filter(c => c.id.endsWith("@c.us")); +} + +export function getGroups() { + return chats.filter(c => c.id.endsWith("@g.us")); +} + +export async function getUser(number) { + if (online) { + return await waha.getUser(number); + } else { + return; + } +} + +export async function getUserAbout(userId) { + if (online) { + return await waha.getUserAbout(userId); + } else { + return; + } +} + +export function getChats() { + return chats; +} + +export async function getAppUser() { + if (online) { + const info = await waha.getMyInfo(); + localStorage.setItem('pandora-last-username', info.name); + localStorage.setItem('pandora-last-userid', info.id); + return info; + } else { + return { + pushName: localStorage.getItem('pandora-last-username') || 'Unknown', + id: localStorage.getItem('pandora-last-userid') || 'Unknown' + } + } +} + +export async function getMessage(chatId, msgId, downloadMedia) { + if (online) { + const newMessage = await waha.getSingleChatMessage(chatId, msgId, downloadMedia); + upsertMessages([newMessage]); + return newMessage; + } else { + return { + id: `${Date.now()}-temp`, + body: "You're offline", + from: "system", + timestamp: new Date().toISOString() + }; + } +} + +export async function getMedia(reqId) { + const cached = await loadMedia(reqId); + if (cached) { + return cached; + } + + try { + if (online) { + const media = await waha.downloadMedia(reqId); + upsertMedia(reqId, media.blob, media.filename); + return media; + } + } catch (error) { + return; + } +} + +export async function getChatMessages(chatId) { + if (online) { + const newMessages = await waha.getChatMessages(chatId); + upsertMessages(newMessages); + return newMessages; + } else { + return await loadLatestMessages(chatId); + } +} + +export async function getMoreChatMessages(chatId, oldestTimestamp, oldestId, limit = 50) { + if (online) { + return waha.getChatMessages(chatId, oldestTimestamp); + } else { + return await loadOlderMessages(chatId, oldestTimestamp, oldestId); + } +} + +export async function getChatPicture(chatId) { + if (online) { + return await waha.getChatPicture(chatId); + } else { + return { url: "" }; + } +} + +export function isOnline() { + return online; +} + +export async function sendStatus(text) { + if (online) { + return await waha.setStatus(text); + } else { + return { + success: false + } + } +} \ No newline at end of file diff --git a/js/ui.js b/js/ui.js new file mode 100644 index 0000000..d2e1261 --- /dev/null +++ b/js/ui.js @@ -0,0 +1,396 @@ +import { formatTime, normalizeId } from "./utils.js"; +import { getChatPicture, getMessage, getMedia, getMoreChatMessages } from "./storage.js"; +import { getCurrentChat } from "./app.js"; + +export const elements = { + chatList: document.getElementById('chat-list'), + chatsLoader: document.getElementById('chats-loader'), + chatSearch: document.getElementById('chat-search'), + backendStatusText: document.getElementById('backend-status-text'), + apiStatusIndicator: document.querySelector('.pulse-dot'), + noChatState: document.getElementById('no-chat-state'), + activeChatContainer: document.getElementById('active-chat-container'), + activeChatName: document.getElementById('active-chat-name'), + activeChatAvatar: document.getElementById('active-chat-avatar'), + messagesContainer: document.getElementById('messages-container'), + messageForm: document.getElementById('message-form'), + messageInput: document.getElementById('message-input'), + backToSidebarBtn: document.querySelector('.chat-header'), + sidebar: document.querySelector('.sidebar'), + appContainer: document.querySelector('.app-container'), + settingsModal: document.getElementById('settings-page'), + settingsIconBtn: document.getElementById('settings-sidebar-btn'), + saveSettingsBtn: document.getElementById('save-settings'), + inputWahaUrl: document.getElementById('settings-waha-url'), + inputSession: document.getElementById('settings-session'), + inputApiKey: document.getElementById('settings-api-key'), + inputBackgroundImage: document.getElementById('settings-background-image'), + inputBackgroundOpacity: document.getElementById('settings-background-opacity'), + loggedUserName: document.getElementById('pandora-username'), + chatBottomBar: document.getElementById('chat-bottom-bar'), + chatBottomBarBtn: document.getElementById('chat-bottom-bar-btn'), + chatInputPanel: document.getElementById('chat-input-panel'), + attachmentInput: document.getElementById('attachment-input'), + attachmentBtn: document.getElementById('attachment-btn'), + extraPages: document.querySelectorAll('.extra-page'), + desktopSidebarButtons: document.querySelectorAll("#desktop-aside button"), + contentUserName: document.querySelectorAll('[data-content="app-user"]'), + contentUserNumber: document.querySelectorAll('[data-content="app-user-number"]'), + resourceUserPic: document.querySelectorAll('[data-resource="app-user-image"]'), + valueUserStatus: document.querySelectorAll('[data-value="app-user-status"]'), + inputUserStatus: document.getElementById('profile-page-status-input'), + selectable: document.querySelectorAll('.selectable'), +}; + +export const ui = { + showExtraPage(pageId) { + elements.extraPages.forEach(page => { + if (page.id != pageId) { + page.style.display = "none"; + } else { + page.style.display = "flex"; + } + }) + }, + + /** + * Switch view state when a contact chat is opened or closed + */ + toggleChatState(hasActive) { + if (hasActive) { + elements.noChatState.classList.add('hidden'); + elements.activeChatContainer.classList.remove('hidden'); + } else { + elements.noChatState.classList.remove('hidden'); + elements.activeChatContainer.classList.add('hidden'); + } + }, + + /** + * Scroll message list automatically to bottom + */ + scrollToBottom() { + elements.messagesContainer.scrollTop = elements.messagesContainer.scrollHeight; + }, + + /** + * Update connection status badge in sidebar footer + */ + updateConnectionStatus(isConnected, text) { + elements.backendStatusText.textContent = text; + if (isConnected) { + elements.apiStatusIndicator.style.backgroundColor = 'var(--online-color)'; + elements.apiStatusIndicator.style.animation = 'pulse 1.8s infinite'; + } else { + elements.apiStatusIndicator.style.backgroundColor = '#ef4444'; + elements.apiStatusIndicator.style.animation = 'none'; + } + }, + + async renderChatList(chats, activeChat, onChatSelect) { + elements.chatList.innerHTML = ''; + chats.sort((a, b) => b.timestamp - a.timestamp); + + if (chats.length === 0) { + elements.chatList.innerHTML = `
  • No chats found
    • `; + return; + } + + for (const chat of chats) { + const li = document.createElement('li'); + li.className = `chat-item selectable ${activeChat && activeChat.id === chat.id ? 'active' : ''}`; + li.dataset.id = chat.id; + + const initials = chat.name ? chat.name.substring(0, 1).toUpperCase() : '?'; + const hasUnread = chat.unreadCount && chat.unreadCount > 0; + const timeStr = formatTime(chat.timestamp || new Date()); + + li.innerHTML = ` +
    + ${initials} +
    +
    +
    + ${chat.name} + ${timeStr} +
    +
    + + ${chat.lastMessage || 'No messages yet'} + + ${hasUnread ? `${chat.unreadCount}` : ''} +
    +
    + `; + + li.addEventListener('click', () => onChatSelect(chat)); + elements.chatList.appendChild(li); + + (async () => { + try { + const picture = await getChatPicture(chat.id); + const img = li.querySelector(`img[data-chat-avatar="${chat.id}"]`); + if (img) img.src = picture.url ? picture.url : ''; + } catch (e) { + } + })(); + } + }, + + async updateChatInChatList(msg) { + const chat = document.querySelector(`.chat-item[data-id="${msg.fromMe ? msg.to : msg.from}"]`); + + if (chat) { + const messageItem = chat.querySelector('.chat-item-msg'); + const time = chat.querySelector('.chat-item-time') + messageItem.innerText = msg.body || msg.text || 'Media message'; + time.innerText = msg.timestamp ? formatTime(msg.timestamp) : Date.now(); + + const activeChatState = getCurrentChat(); + + if (!msg.fromMe && (!activeChatState || activeChatState.id !== (msg.fromMe ? msg.to : msg.from))) { + const unreadBadge = chat.querySelector('.unread-badge'); + unreadBadge.innerText = (Number(unreadBadge.innerHTML) || 0) + 1; + } + } + }, + + /** + * Render chat message log inside chat view container + */ + async renderMessages(messages, activeChatName, userID, chatId) { + elements.messagesContainer.innerHTML = ''; + + if (messages.length === 0) { + elements.messagesContainer.innerHTML = '
    No messages. Say hello!
    '; + return; + } + + const loadMore = document.createElement("button"); + loadMore.classList.add("load-more-btn"); + loadMore.innerText = "Load more"; + loadMore.addEventListener('click', () => { + this.loadMoreMessages(chatId, userID); + }); + elements.messagesContainer.appendChild(loadMore); + + for (const msg of messages) { + this.appendSingleMessage(msg, userID, chatId); + } + + this.scrollToBottom(); + }, + + async loadMoreMessages(chatId, userId) { + const oldest = document.querySelector('.message-group:first-of-type'); + const oldestTimestamp = oldest.dataset.timestamp; + const oldestId = oldest.id; + console.log(oldest) + console.log(oldestId) + console.log(oldestTimestamp) + + const loadMoreButton = document.querySelector('.load-more-btn'); + loadMoreButton.removeEventListener('click', this.loadMoreMessages); + + const msgs = await getMoreChatMessages(chatId, oldestTimestamp, oldestId); + msgs.shift(); + + msgs.forEach(async msg => { + loadMoreButton.after(this.generateMessage(msg, userId, chatId)); + }); + + loadMoreButton.addEventListener('click', this.loadMoreMessages); + }, + + /** + * Append a single message (used for optimistic updates immediately upon sending) + */ + appendSingleMessage(msg, userID, chatId, isLocal = false) { + elements.messagesContainer.appendChild(this.generateMessage(msg, userID, chatId, isLocal)) + }, + + generateTempMessageLink(msg) { + const a = document.createElement('a'); + a.target = "_blank"; + a.href = msg.media.url; + + if (msg._data?.mimetype?.startsWith('image/')) { + const img = document.createElement('img'); + img.classList.add('message-image-attachement'); + img.src = msg.media.url; + a.appendChild(img); + } else { + a.textContent = msg.media.filename || "Download file"; + a.download = msg.media.filename; + } + + return a; + }, + + generateMessage(msg, userID, chatId, isLocal = false) { + const isOutgoing = msg.fromMe || msg.sender === 'me'; + + function getPrevMessageElem() { + return elements.messagesContainer.lastElementChild; + } + + const prevMsgEl = getPrevMessageElem(); + + const groupDiv = document.createElement('div'); + groupDiv.className = `message-group selectable ${isOutgoing ? 'outgoing' : 'incoming'}`; + groupDiv.id = normalizeId(msg._serialized ? msg : msg.id); + groupDiv.dataset.timestamp = msg.timestamp; + groupDiv.dataset.from = msg.participant || msg.from; + + const senderName = isOutgoing ? userID : (msg._data.notifyName || msg.from); + const timeStr = formatTime(msg.timestamp || new Date()); + + let statusCheck = ''; + if (isOutgoing) { + if (msg.status === 'read') { + statusCheck = ''; + } else if (msg.status === 'delivered') { + statusCheck = ''; + } else if (msg.status === 'sending') { + statusCheck = ''; + } else { + statusCheck = ''; + } + } + + const bubble = document.createElement('div'); + bubble.className = 'message-bubble'; + + let prevUid; + + if (msg.participant) { + prevUid = msg.participant; + } else { + prevUid = msg.from; + } + + if (!isOutgoing && (!prevMsgEl || prevUid !== prevMsgEl.dataset.from)) { + const senderEl = document.createElement('span'); + senderEl.className = 'message-sender'; + senderEl.textContent = senderName; + bubble.appendChild(senderEl); + } + + const contentEl = document.createElement('div'); + contentEl.classList.add('message-content'); + const textEl = document.createElement('div'); + textEl.innerHTML = msg.body || msg.text || ""; + contentEl.appendChild(textEl); + bubble.appendChild(contentEl); + + if (msg.hasMedia) { + let a; + + if (isLocal) { + a = this.generateTempMessageLink(msg); + } else { + a = document.createElement('a'); + a.innerText = `[Request media]`; + a.target = "_blank"; + + const clickListener = async (e) => { + a.removeEventListener('click', clickListener); + a.innerText = `[Downloading]`; + const mediaMsg = msg.media ? msg : await getMessage(chatId, normalizeId(msg._serialized ? msg : msg.id), true); + if (!mediaMsg || !mediaMsg?.media.url) { + a.addEventListener('click', clickListener); + a.innerText = `[Error, click to try again]` + return; + } + const url = new URL(mediaMsg.media.url); + const reqID = url.pathname.split('/').filter(Boolean).pop(); + + const { blob, filename } = await getMedia(reqID); + + const objectUrl = URL.createObjectURL(blob); + e.target.href = objectUrl; + + if (blob.type.startsWith('image/')) { + a.textContent = ""; + const img = document.createElement('img'); + img.classList.add('message-image-attachement'); + img.src = objectUrl; + bubble.after(img); + bubble.querySelector('.message-content').remove(); + } else { + e.target.textContent = filename || `Download ${mediaMsg.media.filename}`; + } + } + + a.addEventListener('click', clickListener); + } + + contentEl.appendChild(a); + + if (!isLocal && msg._data?.mimetype?.startsWith('image/')) { + a.click(); + } + } + + + const meta = document.createElement('div'); + meta.className = 'message-meta'; + meta.innerHTML = `${timeStr}${statusCheck}`; + + bubble.appendChild(meta); + + if (isOutgoing) { + if (prevMsgEl && prevMsgEl.classList.contains('outgoing')) { + groupDiv.classList.add('same-sender'); + } else { + groupDiv.appendChild(document.createElement('div')).className = 'message-indicator'; + } + } else if (msg.participant) { + if (!prevMsgEl || prevUid !== prevMsgEl.dataset.from) { + groupDiv.appendChild(document.createElement('div')).className = 'message-indicator'; + } else groupDiv.classList.add('same-sender'); + } else { + if (!prevMsgEl || prevUid !== prevMsgEl.dataset.from) { + groupDiv.appendChild(document.createElement('div')).className = 'message-indicator'; + } else groupDiv.classList.add('same-sender'); + } + + groupDiv.appendChild(bubble); + return groupDiv; + }, + + updateMessage(originalMsgId, generatedMsg) { + const originalMsg = document.querySelector(`#${originalMsgId}`); + if (originalMsg) { + originalMsg.replaceWith(generatedMsg) + } + }, + + updateMessageTick(id, status) { + let statusCheck; + if (status === 'read') { + statusCheck = ''; + } else if (status === 'delivered') { + statusCheck = ''; + } else if (status === 'sending') { + statusCheck = ''; + } else { + statusCheck = ''; + } + + document.getElementById(id).querySelector('.message-meta').outerHTML = statusCheck; + }, + + toggleChatBottomBar() { + elements.chatBottomBar.classList.toggle("collapsed"); + }, + + removeChatMessage(msgId) { + const message = document.getElementById(msgId); + if (message) message.remove(); + } +}; diff --git a/public/utils.js b/js/utils.js similarity index 74% rename from public/utils.js rename to js/utils.js index 4f2ca61..81f05f0 100644 --- a/public/utils.js +++ b/js/utils.js @@ -79,3 +79,45 @@ export function compensateMessageOrdering(messages) { // Clean up temporary property return msgs.map(({ _time, ...m }) => m); } + +export function getBase64(file) { + return new Promise((resolve, reject) => { + const reader = new FileReader(); + + reader.onload = () => { + resolve(reader.result.split(",")[1]); + }; + + reader.onerror = (e) => { + console.error("Error", e); + reject(e); + }; + + reader.onabort = () => { + reject(new Error("Aborted")); + }; + + reader.readAsDataURL(file); + }); +} + +/** + * Normalize a WhatsApp ID (chatId, messageId, etc.) to its string representation + * @param {string|object} raw + * @returns {string|null} + */ +export function normalizeId(raw) { + if (!raw) return null; + if (typeof raw === 'object') { + return raw._serialized || raw.user || JSON.stringify(raw); + } + return raw; +} + +export function debounce(func, delay) { + let timeoutId; + return function() { + clearTimeout(timeoutId); + timeoutId = setTimeout(func, delay); + }; +} \ No newline at end of file diff --git a/js/waha.js b/js/waha.js new file mode 100644 index 0000000..2c5c077 --- /dev/null +++ b/js/waha.js @@ -0,0 +1,186 @@ +import { config } from "./config.js"; +import { getBase64 } from "./utils.js"; + +async function request(path, options = {}) { + const url = `${config.wahaUrl}${path}`; + const headers = { + 'Content-Type': 'application/json', + 'accept': '*/*', + ...options.headers + }; + if (config.apiKey) { + headers['X-Api-Key'] = config.apiKey; + } + + // console.log(`[WAHA] ${options.method || 'GET'} ${url}`, options.body ? JSON.parse(options.body) : ''); + + const response = await fetch(url, { ...options, headers }); + if (!response.ok) { + let errorDetail = ''; + try { + const errBody = await response.json(); + errorDetail = JSON.stringify(errBody); + console.error(`[WAHA] Error response body:`, errBody); + } catch (_) { + errorDetail = await response.text().catch(() => ''); + } + throw new Error(`WAHA API returned ${response.status}: ${response.statusText} — ${errorDetail}`); + } + return response.json(); +} + +async function downloadFile(path, options = {}) { + const url = `${config.wahaUrl}${path}`; + + const headers = { + 'Content-Type': options.headers?.['Content-Type'] ?? 'application/json', + 'accept': '*/*', + ...options.headers + }; + + if (config.apiKey) headers['X-Api-Key'] = config.apiKey; + +// console.log(`[WAHA] ${options.method || 'GET'} ${url}`); + + const response = await fetch(url, { ...options, headers }); + + if (!response.ok) { + let errorDetail = ''; + try { + errorDetail = JSON.stringify(await response.json()); + } catch (_) { + errorDetail = await response.text().catch(() => ''); + } + throw new Error(`WAHA API returned ${response.status}: ${response.statusText} — ${errorDetail}`); + } + + const blob = await response.blob(); + + let filename = 'download'; + const cd = response.headers.get('content-disposition'); + if (cd) { + const m = cd.match(/filename\*=UTF-8''([^;]+)|filename="?([^"]+)"?/i); + filename = decodeURIComponent(m?.[1] || m?.[2] || filename); + } + + return { blob, filename }; +} + + +export const waha = { + async getVersion() { + return await request('/api/version'); + }, + + async getChats() { + const data = await request(`/api/${config.session}/chats`); + return data.map(chat => { + let chatId = chat.id; + if (chatId && typeof chatId === "object") { + chatId = chatId._serialized || chatId.user || JSON.stringify(chatId); + } + return { + id: chatId || chat.chatId || chat.name, + name: chat.name || "Unknown Contact", + unreadCount: chat.unreadCount || 0, + lastMessage: chat.lastMessage?.body || chat.lastMessageText || "Click to open chat", + timestamp: chat.lastMessage?.timestamp || new Date() + }; + }); + }, + + async getChatMessages(chatId, beforeTimestamp) { + console.log(`/api/${config.session}/chats/${chatId}/messages?downloadMedia=false&limit=40&sortBy=timestamp${beforeTimestamp ? `&filter.timestamp.gte=${beforeTimestamp}` : "" }`); + return request(`/api/${config.session}/chats/${chatId}/messages?downloadMedia=false&limit=40${beforeTimestamp ? `&filter.timestamp.lte=${beforeTimestamp}` : "" }`); + }, + + async getSingleChatMessage(chatId, messageId, downladMedia) { + return request(`/api/${config.session}/chats/${chatId}/messages/${messageId}?downloadMedia=${downladMedia}`); + }, + + async getChatPicture(chatId) { + return request(`/api/${config.session}/chats/${chatId}/picture`); + }, + + async getUser(chatId) { + return request(`/api/${config.session}/contacts/${chatId}`); + }, + + async getUserAbout(chatId) { + return request(`/api/contacts/about?contactId=${chatId}&session=${config.session}`); + }, + + async readChat(chatId) { + return request('/api/sendSeen', { + method: 'POST', + body: JSON.stringify({ chatId, session: config.session }) + }); + }, + + async downloadMedia(file) { + const { blob, filename } = await downloadFile(`/api/files/${config.session}/${file}`); + return { blob, filename }; + }, + + async getMyInfo() { + return request(`/api/sessions/${config.session}/me`); + }, + + async startTyping(chatId) { + return request('/api/startTyping', { + method: 'POST', + body: JSON.stringify({ chatId, session: config.session }) + }); + }, + + async stopTyping(chatId) { + return request('/api/stopTyping', { + method: 'POST', + body: JSON.stringify({ chatId, session: config.session }) + }); + }, + + async sendTextMessage(chatId, text) { + return request('/api/sendText', { + method: 'POST', + body: JSON.stringify({ + chatId, + text, + session: config.session + }) + }); + }, + + async setStatus(text) { + return request(`/api/${config.session}/profile/status`, { + method: 'PUT', + body: JSON.stringify({ + status: text + }) + }); + }, + + async sendFileMessage(chatId, file) { + const fileBase64 = await getBase64(file); + const body = { + method: 'POST', + body: JSON.stringify({ + chatId, + file: { + mimetype: file.type, + filename: file.name, + data: fileBase64 + }, + session: config.session + }) + }; + + let endpoint = "/api/sendFile"; + + if (file.type.startsWith('image/')) endpoint = '/api/sendImage'; + if (file.type.startsWith('video/')) endpoint = '/api/sendVideo'; + + const result = await request(endpoint, body); + return result; + } +}; diff --git a/public/websocket.js b/js/websocket.js similarity index 93% rename from public/websocket.js rename to js/websocket.js index ab0f073..c1c0aa2 100644 --- a/public/websocket.js +++ b/js/websocket.js @@ -1,4 +1,5 @@ import { config } from "./config.js"; +import { isOnline, updateOnlineStatus } from "./storage.js"; let socket = null; let reconnectTimer = null; @@ -6,6 +7,7 @@ let currentOnMessageCallback = null; export const websocket = { connect(onMessageCallback) { + if (!isOnline) return; currentOnMessageCallback = onMessageCallback; this.disconnect(false); @@ -21,7 +23,7 @@ export const websocket = { const apiKey = config.apiKey; const session = config.session; - const events = ['session.status', 'message', 'message.any']; + const events = ['session.status', 'message.any']; const queryParams = new URLSearchParams(); if (apiKey) { @@ -64,6 +66,7 @@ export const websocket = { socket = null; reconnectTimer = setTimeout(() => { + updateOnlineStatus(); this.connect(currentOnMessageCallback); }, 5000); }; diff --git a/loading.css b/loading.css new file mode 100644 index 0000000..10e4ab3 --- /dev/null +++ b/loading.css @@ -0,0 +1,116 @@ +.loading-animation-wrapper { + width: 200px; + height: 40px; + margin: 10px auto 0 auto; + padding-top: 4px; +} +.loading-animation-wrapper .caption { + margin: 0; + padding: 0; + text-align: center; + color: #fff; + font: 12px/1.4em Arial; +} +.loading-animation-wrapper .dot { + position: relative; + display: inline-block; + width: 10px; + height: 10px; + background: #fff; + -moz-border-radius: 100%; + -webkit-border-radius: 100%; + border-radius: 100%; + -moz-animation: movingdot 4s infinite; + -webkit-animation: movingdot 4s infinite; + animation: movingdot 4s infinite; + -moz-animation-timing-function: cubic-bezier(0.03, 0.615, 0.995, 0.415); + -webkit-animation-timing-function: cubic-bezier(0.03, 0.615, 0.995, 0.415); + animation-timing-function: cubic-bezier(0.03, 0.615, 0.995, 0.415); + -moz-animation-fill-mode: both; + -webkit-animation-fill-mode: both; + animation-fill-mode: both; +} +.loading-animation-wrapper .dot:nth-child(1) { + -moz-animation-delay: 1s; + -webkit-animation-delay: 1s; + animation-delay: 1s; +} +.loading-animation-wrapper .dot:nth-child(2) { + -moz-animation-delay: 0.9s; + -webkit-animation-delay: 0.9s; + animation-delay: 0.9s; +} +.loading-animation-wrapper .dot:nth-child(3) { + -moz-animation-delay: 0.8s; + -webkit-animation-delay: 0.8s; + animation-delay: 0.8s; +} +.loading-animation-wrapper .dot:nth-child(4) { + -moz-animation-delay: 0.7s; + -webkit-animation-delay: 0.7s; + animation-delay: 0.7s; +} +.loading-animation-wrapper .dot:nth-child(5) { + -moz-animation-delay: 0.6s; + -webkit-animation-delay: 0.6s; + animation-delay: 0.6s; +} + +@-moz-keyframes movingdot { + 0% { + -moz-transform: translateX(-30px); + transform: translateX(-30px); + opacity: 0; + } + 25% { + opacity: 1; + } + 50% { + -moz-transform: translateX(200px); + transform: translateX(200px); + opacity: 0; + } + 100% { + opacity: 0; + } +} +@-webkit-keyframes movingdot { + 0% { + -webkit-transform: translateX(-30px); + transform: translateX(-30px); + opacity: 0; + } + 25% { + opacity: 1; + } + 50% { + -webkit-transform: translateX(200px); + transform: translateX(200px); + opacity: 0; + } + 100% { + opacity: 0; + } +} +@keyframes movingdot { + 0% { + -moz-transform: translateX(-30px); + -ms-transform: translateX(-30px); + -webkit-transform: translateX(-30px); + transform: translateX(-30px); + opacity: 0; + } + 25% { + opacity: 1; + } + 50% { + -moz-transform: translateX(200px); + -ms-transform: translateX(200px); + -webkit-transform: translateX(200px); + transform: translateX(200px); + opacity: 0; + } + 100% { + opacity: 0; + } +} diff --git a/manifest.json b/manifest.json new file mode 100644 index 0000000..0cde8f6 --- /dev/null +++ b/manifest.json @@ -0,0 +1,23 @@ +{ + "name": "PANDORA chat", + "short_name": "PANDORA", + "theme_color": "#ffffff", + "background_color": "#102457", + "display": "standalone", + "orientation": "any", + "scope": "./", + "start_url": "./", + "description": "Internet messaging", + "icons": [ + { + "src": "icon-192.png", + "sizes": "192x192", + "type": "image/png" + }, + { + "src": "icon-512.png", + "sizes": "512x512", + "type": "image/png" + } + ] +} diff --git a/message-long.ogg b/message-long.ogg new file mode 100644 index 0000000..14b22c2 Binary files /dev/null and b/message-long.ogg differ diff --git a/message.ogg b/message.ogg new file mode 100644 index 0000000..709e9d5 Binary files /dev/null and b/message.ogg differ diff --git a/metroicons.css b/metroicons.css new file mode 100644 index 0000000..223e77f --- /dev/null +++ b/metroicons.css @@ -0,0 +1 @@ +@font-face{font-family:metro;font-style:normal;font-weight:400;src:url(data:application/font-woff;base64,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)}[class*=mif-]{speak:none;display:inline-block;font-family:metro!important;font-style:normal;font-variant:normal;font-weight:400;line-height:1;position:relative;text-transform:none}.mif-lg{font-size:1.2em}.mif-2x{font-size:1.5em}.mif-3x{font-size:2em}.mif-4x{font-size:2.5em}.mif-5x{font-size:3em}.mif-6x{font-size:3.5em}.mif-7x{font-size:4em}.mif-8x{font-size:4.5em}.mif-9x{font-size:5em}.mif-10x{font-size:5.5em}.mif-code-slash:before{content:"\ea7f"}.mif-code:before{content:"\ea80"}.mif-designing:before{content:"\eac4"}.mif-avi-file:before{content:"\eac5"}.mif-html-file:before{content:"\eac7"}.mif-mp4-file:before{content:"\eac9"}.mif-log-file:before{content:"\eaca"}.mif-format2:before{content:"\eacb"}.mif-format:before{content:"\eacc"}.mif-format-table:before{content:"\eacd"}.mif-format-document:before{content:"\eace"}.mif-format-image:before{content:"\eacf"}.mif-format-formula:before{content:"\ead0"}.mif-format-code:before{content:"\ead1"}.mif-typescript:before{content:"\ead2"}.mif-javascript:before{content:"\ead3"}.mif-css3:before{content:"\ead4"}.mif-html5:before{content:"\ead5"}.mif-codescan:before{content:"\ead6"}.mif-run-person:before{content:"\ead7"}.mif-database-server:before{content:"\e964"}.mif-database-select:before{content:"\e9f2"}.mif-database-layer:before{content:"\e9f3"}.mif-database:before{content:"\eaa4"}.mif-database-sand:before{content:"\eaa5"}.mif-database-upload:before{content:"\eaa6"}.mif-database-edit:before{content:"\eaa7"}.mif-databases:before{content:"\eaa8"}.mif-database-download:before{content:"\eaa9"}.mif-database-undo:before{content:"\eaaa"}.mif-database-time1:before{content:"\eaab"}.mif-database-net:before{content:"\eaac"}.mif-database-minus:before{content:"\eaad"}.mif-database-reload:before{content:"\eaaf"}.mif-database-cancel:before{content:"\eab1"}.mif-database-search:before{content:"\eab2"}.mif-database-star:before{content:"\eab3"}.mif-database-time:before{content:"\eab4"}.mif-database-lock:before{content:"\eab6"}.mif-database-cloud:before{content:"\eab7"}.mif-database-ok:before{content:"\eab8"}.mif-database-error:before{content:"\eab9"}.mif-database-favorite:before{content:"\eaba"}.mif-share-circle:before{content:"\eabb"}.mif-brackets-hexagon:before{content:"\eabc"}.mif-brackets:before{content:"\eabd"}.mif-group-by-ref:before{content:"\eabe"}.mif-build:before{content:"\ea74"}.mif-quickedit:before{content:"\ea75"}.mif-query:before{content:"\ea88"}.mif-graphql:before{content:"\ea9e"}.mif-mssql:before{content:"\ea9f"}.mif-mysql:before{content:"\eaa0"}.mif-zoom:before{content:"\eaa1"}.mif-postgresql:before{content:"\eaa2"}.mif-sql:before{content:"\eaa3"}.mif-export:before{content:"\e917"}.mif-import:before{content:"\e918"}.mif-database-next:before{content:"\e919"}.mif-database-prev:before{content:"\e91a"}.mif-database-down:before{content:"\e91c"}.mif-database-up:before{content:"\e922"}.mif-iso-file:before{content:"\e923"}.mif-eps-file:before{content:"\e93b"}.mif-xls-file:before{content:"\e93c"}.mif-jpg-file:before{content:"\e93d"}.mif-doc-file:before{content:"\e93e"}.mif-fnt-file:before{content:"\e943"}.mif-png-file:before{content:"\e944"}.mif-pdf-file:before{content:"\e946"}.mif-csv-file:before{content:"\e947"}.mif-github:before{content:"\e94c"}.mif-whatsapp1:before{content:"\e94e"}.mif-viber:before{content:"\e94f"}.mif-telegram:before{content:"\e950"}.mif-discord:before{content:"\e951"}.mif-sql-file:before{content:"\e952"}.mif-warning1:before{content:"\e958"}.mif-add_alert:before{content:"\e95b"}.mif-notification_important:before{content:"\e95c"}.mif-add_to_queue:before{content:"\e9ee"}.mif-video_call:before{content:"\e9f0"}.mif-clear_all:before{content:"\e95d"}.mif-email:before{content:"\ea6b"}.mif-key2:before{content:"\e9fd"}.mif-present_to_all:before{content:"\e9f4"}.mif-mail_outline:before{content:"\e95e"}.mif-screen_share:before{content:"\ea70"}.mif-stop_screen_share:before{content:"\ea7d"}.mif-alternate_email:before{content:"\ea6c"}.mif-cancel_presentation:before{content:"\e9f5"}.mif-pause_presentation:before{content:"\e9f6"}.mif-unsubscribe:before{content:"\ea81"}.mif-add1:before{content:"\e9f7"}.mif-block:before{content:"\e95f"}.mif-drafts1:before{content:"\ea83"}.mif-link_on:before{content:"\ea84"}.mif-remove_circle_outline:before{content:"\e967"}.mif-report:before{content:"\e968"}.mif-floppy-disk3:before{content:"\eac0"}.mif-link_off:before{content:"\ea85"}.mif-add_link:before{content:"\e9f8"}.mif-add_alarm:before{content:"\e9f9"}.mif-now_widgets:before{content:"\e9e0"}.mif-attach_money:before{content:"\e969"}.mif-format_ltr:before{content:"\e96a"}.mif-format_rtl:before{content:"\e96d"}.mif-add_comment:before{content:"\e9fa"}.mif-folder3:before{content:"\ea86"}.mif-folder_open:before{content:"\ea89"}.mif-create_new_folder:before{content:"\e9fb"}.mif-cast1:before{content:"\ea8a"}.mif-desktop_mac:before{content:"\e96e"}.mif-desktop_windows:before{content:"\e96f"}.mif-laptop_chromebook:before{content:"\e970"}.mif-tablet_mac:before{content:"\e976"}.mif-toys:before{content:"\e977"}.mif-tv:before{content:"\e978"}.mif-watch:before{content:"\e97c"}.mif-device_hub:before{content:"\e9fc"}.mif-devices_other:before{content:"\e97e"}.mif-camera_front:before{content:"\e9e2"}.mif-camera_rear:before{content:"\e9e3"}.mif-hdr_strong:before{content:"\e9e4"}.mif-hdr_weak:before{content:"\e9e5"}.mif-loupe:before{content:"\e9fe"}.mif-nature:before{content:"\e9e6"}.mif-nature_people:before{content:"\e9e8"}.mif-picture_as_pdf:before{content:"\ea8b"}.mif-view_compact:before{content:"\ea8c"}.mif-photo_size_select_actual:before{content:"\ea8e"}.mif-add_a_photo:before{content:"\e9ff"}.mif-photo_filter:before{content:"\ea00"}.mif-add_photo_alternate:before{content:"\ea01"}.mif-category:before{content:"\ea02"}.mif-cancel1:before{content:"\e97f"}.mif-folder_special:before{content:"\ea03"}.mif-enhanced_encryption:before{content:"\ea04"}.mif-priority_high:before{content:"\e980"}.mif-bubble_chart:before{content:"\e9e9"}.mif-group:before{content:"\ea8f"}.mif-group_add:before{content:"\ea05"}.mif-notifications:before{content:"\e984"}.mif-notifications_none:before{content:"\e985"}.mif-notifications_off:before{content:"\e98e"}.mif-notifications_on:before{content:"\e98f"}.mif-people_outline:before{content:"\ea06"}.mif-person:before{content:"\ea11"}.mif-person_add:before{content:"\ea15"}.mif-person_outline:before{content:"\ea16"}.mif-account_circle:before{content:"\ea17"}.mif-assignment_ind:before{content:"\ea90"}.mif-face:before{content:"\ea18"}.mif-help1:before{content:"\e990"}.mif-highlight_remove:before{content:"\e996"}.mif-info:before{content:"\e998"}.mif-info_outline:before{content:"\e9a0"}.mif-note_add:before{content:"\ea19"}.mif-settings_input_antenna:before{content:"\ea1a"}.mif-settings_remote:before{content:"\ea1b"}.mif-settings_voice:before{content:"\ea31"}.mif-shopping_basket:before{content:"\e9a1"}.mif-spellcheck:before{content:"\ea32"}.mif-stars:before{content:"\e9a2"}.mif-supervisor_account:before{content:"\ea33"}.mif-system_update_tv:before{content:"\ea34"}.mif-help_outline:before{content:"\e9a4"}.mif-zoom_in:before{content:"\ea35"}.mif-zoom_out:before{content:"\ea36"}.mif-copyright1:before{content:"\e9a7"}.mif-important_devices:before{content:"\ea37"}.mif-record_voice_over1:before{content:"\ea92"}.mif-check_circle_outline:before{content:"\e9ab"}.mif-minimize:before{content:"\ea93"}.mif-supervised_user_circle:before{content:"\ea38"}.mif-voice_over_off:before{content:"\ea94"}.mif-filter_list_alt:before{content:"\e9ad"}.mif-add_chart:before{content:"\ea41"}.mif-add_moderator:before{content:"\ea42"}.mif-dashboard_customize:before{content:"\ea43"}.mif-mark_as_unread:before{content:"\e9ae"}.mif-menu_open:before{content:"\e9af"}.mif-file_present:before{content:"\ea44"}.mif-post_add:before{content:"\ea48"}.mif-people_alt:before{content:"\ea49"}.mif-metro:before{content:"\ea96"}.mif-volunteer_activism:before{content:"\e9ea"}.mif-child_care:before{content:"\ea97"}.mif-add_business:before{content:"\ea4a"}.mif-admin_panel_settings:before{content:"\ea4b"}.mif-alt_route:before{content:"\ea50"}.mif-attach_email:before{content:"\ea51"}.mif-auto_awesome_motion:before{content:"\e9b1"}.mif-calculate:before{content:"\e9b2"}.mif-construction:before{content:"\e9b4"}.mif-face_retouching_natural:before{content:"\ea98"}.mif-forward_to_inbox:before{content:"\ea52"}.mif-hdr_enhanced_select:before{content:"\e9b5"}.mif-help_center:before{content:"\e9bd"}.mif-maps_ugc:before{content:"\ea53"}.mif-mark_email_read:before{content:"\ea6d"}.mif-mark_email_unread:before{content:"\ea6e"}.mif-mediation:before{content:"\e9eb"}.mif-medical_services:before{content:"\ea54"}.mif-military_tech:before{content:"\e9ec"}.mif-more_time:before{content:"\ea55"}.mif-outgoing_mail:before{content:"\ea6f"}.mif-person_add_alt:before{content:"\ea56"}.mif-person_add_alt_1:before{content:"\ea59"}.mif-person_remove:before{content:"\ea5c"}.mif-person_search:before{content:"\ea5d"}.mif-roofing:before{content:"\ea9a"}.mif-room_preferences:before{content:"\ea9b"}.mif-rule:before{content:"\e9be"}.mif-sensor_door:before{content:"\ea9c"}.mif-support_agent:before{content:"\e9bf"}.mif-reduce_capacity:before{content:"\e9ed"}.mif-facebook1:before{content:"\e9c0"}.mif-groups:before{content:"\ea9d"}.mif-memory:before{content:"\e9d4"}.mif-external:before{content:"\e9c6"}.mif-ac_unit:before{content:"\eb3b"}.mif-accessible:before{content:"\e916"}.mif-adb:before{content:"\e6d8"}.mif-add:before{content:"\e145"}.mif-add-photo:before{content:"\e439"}.mif-arrow-drop-down:before{content:"\e5c5"}.mif-arrow-drop-up:before{content:"\e5c7"}.mif-assignment:before{content:"\e85d"}.mif-backspace1:before{content:"\e14a"}.mif-beenhere:before{content:"\e52d"}.mif-cake:before{content:"\e7e9"}.mif-photo-camera:before{content:"\e412"}.mif-photo-camera-enhance:before{content:"\e8fc"}.mif-camera-front:before{content:"\e3b1"}.mif-camera-rear:before{content:"\e3b2"}.mif-chat:before{content:"\e0b7"}.mif-chat-bubble:before{content:"\e0ca"}.mif-chat-bubble-outline:before{content:"\e0cb"}.mif-comment:before{content:"\e0b9"}.mif-developer_board:before{content:"\e30d"}.mif-done:before{content:"\e876"}.mif-done_all:before{content:"\e877"}.mif-flash-auto:before{content:"\e3e5"}.mif-flash-off:before{content:"\e3e6"}.mif-flash-on:before{content:"\e3e7"}.mif-qa:before{content:"\e8af"}.mif-hdr-off:before{content:"\e3ed"}.mif-hdr-on:before{content:"\e3ee"}.mif-http:before{content:"\e909"}.mif-import-export:before{content:"\e0c3"}.mif-inbox:before{content:"\e156"}.mif-backspace:before{content:"\e317"}.mif-keyboard-tab:before{content:"\e31c"}.mif-restaurant:before{content:"\e561"}.mif-location-off:before{content:"\e0c7"}.mif-room:before{content:"\e8b4"}.mif-move_to_inbox:before{content:"\e168"}.mif-navigation:before{content:"\e55d"}.mif-near-me:before{content:"\e569"}.mif-network-cell:before{content:"\e1b9"}.mif-network-locked:before{content:"\e6d9"}.mif-network-wifi:before{content:"\e1ba"}.mif-cell-setting:before{content:"\e8a4"}.mif-phonelink-erase:before{content:"\e0db"}.mif-phonelink-lock:before{content:"\e0dc"}.mif-phonelink-ring:before{content:"\e0dd"}.mif-phonelink-setup:before{content:"\e0de"}.mif-present-all:before{content:"\e0df"}.mif-record_voice_over:before{content:"\e91f"}.mif-refresh:before{content:"\e5d5"}.mif-replay:before{content:"\e042"}.mif-reply:before{content:"\e15e"}.mif-reply_all:before{content:"\e15f"}.mif-lock-rotation:before{content:"\e1c0"}.mif-rotation:before{content:"\e1c1"}.mif-cell-on:before{content:"\e1c8"}.mif-cell-no-internet:before{content:"\e1cd"}.mif-cell-null:before{content:"\e1cf"}.mif-cell-off:before{content:"\e1d0"}.mif-wifi-lock:before{content:"\e1d9"}.mif-wifi-off:before{content:"\e1da"}.mif-verified:before{content:"\e8e8"}.mif-add-shopping-cart:before{content:"\e854"}.mif-cast:before{content:"\e307"}.mif-cast-connected:before{content:"\e308"}.mif-dashboard:before{content:"\e871"}.mif-description:before{content:"\e873"}.mif-equalizer2:before{content:"\e01d"}.mif-ev-station:before{content:"\e56d"}.mif-featured-play-list:before{content:"\e06d"}.mif-featured-video:before{content:"\e06e"}.mif-fingerprint:before{content:"\e912"}.mif-folder2:before{content:"\e2c7"}.mif-folder-open2:before{content:"\e2c8"}.mif-folder-shared:before{content:"\e2c9"}.mif-folder-special2:before{content:"\e6c4"}.mif-goat:before{content:"\e901"}.mif-import-contacts:before{content:"\e0e0"}.mif-insert-drive-file:before{content:"\e24d"}.mif-keyboard-hide:before{content:"\e31a"}.mif-note:before{content:"\e06f"}.mif-note-add:before{content:"\e89c"}.mif-pan-tool:before{content:"\e939"}.mif-directions-bike:before{content:"\e6bf"}.mif-location-city:before{content:"\e6c0"}.mif-wifi-low:before{content:"\e60c"}.mif-wifi-mid:before{content:"\e60d"}.mif-wifi-full:before{content:"\e634"}.mif-tablet-landscape:before{content:"\e635"}.mif-calculator2:before{content:"\e636"}.mif-barbell:before{content:"\e637"}.mif-chart-line:before{content:"\e656"}.mif-3d-rotation:before{content:"\e600"}.mif-alarm:before{content:"\e601"}.mif-alarm-on:before{content:"\e602"}.mif-favorite:before{content:"\e603"}.mif-perm-phone-msg:before{content:"\e604"}.mif-print:before{content:"\e605"}.mif-bt-settings:before{content:"\e606"}.mif-settings-ethernet:before{content:"\e607"}.mif-settings-phone:before{content:"\e608"}.mif-settings-power:before{content:"\e609"}.mif-settings-voice:before{content:"\e60a"}.mif-shopping-basket:before{content:"\e60b"}.mif-dialer-sip:before{content:"\e60e"}.mif-dialpad:before{content:"\e60f"}.mif-contacts-dialer:before{content:"\e610"}.mif-contacts-mail:before{content:"\e611"}.mif-ring-volume:before{content:"\e612"}.mif-voicemail:before{content:"\e613"}.mif-drafts:before{content:"\e614"}.mif-mail:before{content:"\e615"}.mif-bluetooth:before{content:"\e626"}.mif-bt-connected:before{content:"\e627"}.mif-bt-disabled:before{content:"\e628"}.mif-bt-searching:before{content:"\e629"}.mif-brightness-auto:before{content:"\e62a"}.mif-multitrack-audio:before{content:"\e616"}.mif-widgets:before{content:"\e617"}.mif-usb1:before{content:"\e638"}.mif-money:before{content:"\e639"}.mif-vertical-align-bottom:before{content:"\e63a"}.mif-vertical-align-center:before{content:"\e63b"}.mif-vertical-align-top:before{content:"\e63c"}.mif-file-download:before{content:"\e63d"}.mif-file-upload:before{content:"\e63e"}.mif-keyboard-return:before{content:"\e63f"}.mif-keyboard-voice:before{content:"\e640"}.mif-phonelink:before{content:"\e641"}.mif-phonelink-off:before{content:"\e642"}.mif-security:before{content:"\e618"}.mif-looks:before{content:"\e643"}.mif-palette:before{content:"\e619"}.mif-layers:before{content:"\e644"}.mif-layers-clear:before{content:"\e61a"}.mif-local-airport:before{content:"\e645"}.mif-florist:before{content:"\e61b"}.mif-gas-station:before{content:"\e61c"}.mif-hotel:before{content:"\e646"}.mif-local-service:before{content:"\e61d"}.mif-map2:before{content:"\e620"}.mif-my-location:before{content:"\e61e"}.mif-traff:before{content:"\e621"}.mif-apps:before{content:"\e647"}.mif-chevron-left:before{content:"\e648"}.mif-chevron-right:before{content:"\e649"}.mif-expand-less:before{content:"\e64a"}.mif-expand-more:before{content:"\e64b"}.mif-menu:before{content:"\e64c"}.mif-more-horiz:before{content:"\e64d"}.mif-more-vert:before{content:"\e64e"}.mif-unfold-less:before{content:"\e64f"}.mif-unfold-more:before{content:"\e650"}.mif-bt-audio:before{content:"\e651"}.mif-not:before{content:"\e633"}.mif-drive-eta:before{content:"\e652"}.mif-event-available:before{content:"\e653"}.mif-event-busy:before{content:"\e654"}.mif-folder-special:before{content:"\e655"}.mif-phone-bt:before{content:"\e657"}.mif-phone-forwarded:before{content:"\e658"}.mif-phone-in-talk:before{content:"\e659"}.mif-phone-locked:before{content:"\e65a"}.mif-phone-missed:before{content:"\e65b"}.mif-phone-paused:before{content:"\e65c"}.mif-sd-card:before{content:"\e65d"}.mif-sync-disabled:before{content:"\e622"}.mif-sync-problem:before{content:"\e623"}.mif-vpn-lock:before{content:"\e624"}.mif-vpn-publ:before{content:"\e625"}.mif-school:before{content:"\e61f"}.mif-floppy-disk2:before{content:"\ea5e"}.mif-drive:before{content:"\ea5f"}.mif-folder-images:before{content:"\ea60"}.mif-folder-music:before{content:"\ea61"}.mif-folder-video:before{content:"\ea66"}.mif-folder1:before{content:"\ea67"}.mif-help2:before{content:"\e9c4"}.mif-info1:before{content:"\e9cf"}.mif-price-ribbon:before{content:"\e9ef"}.mif-google-drive:before{content:"\e9d0"}.mif-paypal1:before{content:"\ea08"}.mif-spotify:before{content:"\ea09"}.mif-linkedin1:before{content:"\ea0c"}.mif-tumblr:before{content:"\ea0e"}.mif-twitter1:before{content:"\ea58"}.mif-cross-light:before{content:"\e9c5"}.mif-install:before{content:"\e902"}.mif-open-book:before{content:"\e903"}.mif-uninstall:before{content:"\e904"}.mif-drive2:before{content:"\e906"}.mif-news:before{content:"\e907"}.mif-book-reference:before{content:"\e908"}.mif-chevron-thin-down:before{content:"\e66b"}.mif-chevron-thin-left:before{content:"\e697"}.mif-chevron-thin-right:before{content:"\e69b"}.mif-chevron-thin-up:before{content:"\e69c"}.mif-flow-branch:before{content:"\e69d"}.mif-flow-cascade:before{content:"\e69e"}.mif-flow-line:before{content:"\e69f"}.mif-flow-parallel:before{content:"\e6a0"}.mif-flow-tree:before{content:"\e6a1"}.mif-air:before{content:"\e6a2"}.mif-medal:before{content:"\e6a3"}.mif-paper-plane:before{content:"\e6a4"}.mif-shareable:before{content:"\e6a5"}.mif-shop:before{content:"\e6a6"}.mif-shopping-basket2:before{content:"\e6a7"}.mif-thumbs-down:before{content:"\e6a8"}.mif-thumbs-up:before{content:"\e6a9"}.mif-traffic-cone:before{content:"\e6aa"}.mif-water:before{content:"\e6ab"}.mif-creative-cloud:before{content:"\e6ac"}.mif-dropbox:before{content:"\e6ad"}.mif-evernote:before{content:"\e6ae"}.mif-paypal:before{content:"\e6af"}.mif-swarm:before{content:"\e6b0"}.mif-vk:before{content:"\e6b1"}.mif-yelp:before{content:"\e6b2"}.mif-dribbble:before{content:"\e6b3"}.mif-lastfm:before{content:"\e6b4"}.mif-pinterest:before{content:"\e6b5"}.mif-stumbleupon:before{content:"\e6b6"}.mif-vimeo:before{content:"\e6b7"}.mif-slideshare:before{content:"\e9f1"}.mif-facebook:before{content:"\f09a"}.mif-steam:before{content:"\f1b6"}.mif-leanpub:before{content:"\f212"}.mif-user-secret:before{content:"\f21b"}.mif-server:before{content:"\f233"}.mif-balance-scale:before{content:"\f24e"}.mif-gitlab:before{content:"\f296"}.mif-themeisle:before{content:"\f2b2"}.mif-handshake:before{content:"\f2b5"}.mif-grav:before{content:"\f2d6"}.mif-imdb:before{content:"\f2d8"}.mif-meetup:before{content:"\f2e0"}.mif-unlink:before{content:"\f127"}.mif-fire-extinguisher:before{content:"\f134"}.mif-eur:before{content:"\f153"}.mif-gbp:before{content:"\f154"}.mif-dollar2:before{content:"\f155"}.mif-cny:before{content:"\f157"}.mif-bitcoin:before{content:"\f15a"}.mif-youtube-play:before{content:"\f16a"}.mif-linux:before{content:"\f17c"}.mif-space-shuttle:before{content:"\f197"}.mif-openid:before{content:"\f19b"}.mif-digg:before{content:"\f1a6"}.mif-language:before{content:"\f1ab"}.mif-automobile:before{content:"\f1b9"}.mif-cab:before{content:"\f1ba"}.mif-jsfiddle:before{content:"\f1cc"}.mif-google-wallet:before{content:"\f1ee"}.mif-copyright:before{content:"\f1f9"}.mif-bicycle:before{content:"\f206"}.mif-bus:before{content:"\f207"}.mif-ship:before{content:"\f21a"}.mif-motorcycle:before{content:"\f21c"}.mif-train:before{content:"\f238"}.mif-subway:before{content:"\f239"}.mif-opencart:before{content:"\f23d"}.mif-trademark:before{content:"\f25c"}.mif-registered:before{content:"\f25d"}.mif-creative-commons:before{content:"\f25e"}.mif-wikipedia:before{content:"\f266"}.mif-amazon:before{content:"\f270"}.mif-fonticons:before{content:"\f280"}.mif-user-md:before{content:"\f0f0"}.mif-stethoscope:before{content:"\f0f1"}.mif-ambulance:before{content:"\f0f9"}.mif-medkit:before{content:"\f0fa"}.mif-paw:before{content:"\f1b0"}.mif-visa:before{content:"\f1f0"}.mif-mastercard:before{content:"\f1f1"}.mif-discover:before{content:"\f1f2"}.mif-amex:before{content:"\f1f3"}.mif-cc-paypal:before{content:"\f1f4"}.mif-heartbeat:before{content:"\f21e"}.mif-venus:before{content:"\f221"}.mif-mars:before{content:"\f222"}.mif-medium:before{content:"\f23a"}.mif-network:before{content:"\e9d1"}.mif-lan:before{content:"\e9dc"}.mif-net-server:before{content:"\e9dd"}.mif-computer:before{content:"\e9de"}.mif-hdd:before{content:"\e9df"}.mif-cpu:before{content:"\e9e1"}.mif-sign-pen:before{content:"\e9c9"}.mif-usb:before{content:"\e9e7"}.mif-stack2:before{content:"\e6b9"}.mif-stack3:before{content:"\e6ba"}.mif-lamp:before{content:"\e6bb"}.mif-injection:before{content:"\e6bc"}.mif-thermometer2:before{content:"\e6bd"}.mif-justice:before{content:"\e6be"}.mif-cabinet:before{content:"\e62b"}.mif-suitcase:before{content:"\e62c"}.mif-gamepad:before{content:"\e65e"}.mif-satellite:before{content:"\e65f"}.mif-lock:before{content:"\e660"}.mif-unlock:before{content:"\e661"}.mif-battery-full:before{content:"\e62d"}.mif-battery-two:before{content:"\e62e"}.mif-battery-one:before{content:"\e62f"}.mif-battery-empty:before{content:"\e630"}.mif-battery-charge:before{content:"\e631"}.mif-tools:before{content:"\e632"}.mif-pin:before{content:"\e662"}.mif-discout:before{content:"\e663"}.mif-profile:before{content:"\e664"}.mif-dollar:before{content:"\e665"}.mif-dollars:before{content:"\e666"}.mif-coins:before{content:"\e6b8"}.mif-male:before{content:"\e667"}.mif-female:before{content:"\e668"}.mif-piano:before{content:"\e669"}.mif-anchor:before{content:"\e66a"}.mif-new-tab:before{content:"\ea7e"}.mif-whatsapp:before{content:"\e90b"}.mif-copy:before{content:"\e92c"}.mif-paste:before{content:"\e92d"}.mif-cut:before{content:"\ea5a"}.mif-earth2:before{content:"\e6c1"}.mif-shit:before{content:"\e6c2"}.mif-broadcast:before{content:"\f048"}.mif-organization:before{content:"\f037"}.mif-squirrel:before{content:"\f0b2"}.mif-steps:before{content:"\f0c7"}.mif-versions:before{content:"\f064"}.mif-microscope:before{content:"\f089"}.mif-library:before{content:"\e921"}.mif-file-binary:before{content:"\f094"}.mif-mail-read:before{content:"\f03c"}.mif-quote:before{content:"\f063"}.mif-sunrise:before{content:"\e66c"}.mif-sun:before{content:"\e66d"}.mif-moon:before{content:"\e66e"}.mif-sun3:before{content:"\e66f"}.mif-windy:before{content:"\e670"}.mif-wind:before{content:"\e671"}.mif-snowflake:before{content:"\e672"}.mif-cloudy:before{content:"\e673"}.mif-cloud2:before{content:"\e674"}.mif-weather:before{content:"\e675"}.mif-weather2:before{content:"\e676"}.mif-weather3:before{content:"\e677"}.mif-lines:before{content:"\e678"}.mif-cloud3:before{content:"\e679"}.mif-lightning:before{content:"\e67a"}.mif-lightning2:before{content:"\e67b"}.mif-rainy:before{content:"\e67c"}.mif-rainy2:before{content:"\e67d"}.mif-windy2:before{content:"\e67e"}.mif-windy3:before{content:"\e67f"}.mif-snowy:before{content:"\e680"}.mif-snowy2:before{content:"\e681"}.mif-snowy3:before{content:"\e682"}.mif-weather4:before{content:"\e683"}.mif-cloudy2:before{content:"\e684"}.mif-cloud4:before{content:"\e685"}.mif-lightning3:before{content:"\e686"}.mif-sun4:before{content:"\e687"}.mif-moon2:before{content:"\e688"}.mif-cloudy3:before{content:"\e689"}.mif-cloud5:before{content:"\e68a"}.mif-cloud6:before{content:"\e68b"}.mif-lightning4:before{content:"\e68c"}.mif-rainy3:before{content:"\e68d"}.mif-rainy4:before{content:"\e68e"}.mif-windy4:before{content:"\e68f"}.mif-windy5:before{content:"\e690"}.mif-snowy4:before{content:"\e691"}.mif-snowy5:before{content:"\e692"}.mif-weather5:before{content:"\e693"}.mif-cloudy4:before{content:"\e694"}.mif-lightning5:before{content:"\e695"}.mif-thermometer:before{content:"\e696"}.mif-none:before{content:"\e698"}.mif-celsius:before{content:"\e699"}.mif-fahrenheit:before{content:"\e69a"}.mif-home:before{content:"\e900"}.mif-pencil:before{content:"\e905"}.mif-eyedropper:before{content:"\e90a"}.mif-paint:before{content:"\e90c"}.mif-image:before{content:"\e90d"}.mif-images:before{content:"\e90e"}.mif-camera:before{content:"\e90f"}.mif-headphones:before{content:"\e910"}.mif-music:before{content:"\e911"}.mif-film:before{content:"\e913"}.mif-video-camera:before{content:"\e914"}.mif-dice:before{content:"\e915"}.mif-wifi-connect:before{content:"\e91b"}.mif-feed:before{content:"\e91d"}.mif-mic:before{content:"\e91e"}.mif-books:before{content:"\e920"}.mif-file-empty:before{content:"\e924"}.mif-files-empty:before{content:"\e925"}.mif-file-text:before{content:"\e926"}.mif-file-picture:before{content:"\e927"}.mif-file-music:before{content:"\e928"}.mif-file-play:before{content:"\e929"}.mif-file-video:before{content:"\e92a"}.mif-file-zip:before{content:"\e92b"}.mif-stack:before{content:"\e92e"}.mif-folder:before{content:"\e92f"}.mif-folder-open:before{content:"\e930"}.mif-folder-plus:before{content:"\e931"}.mif-folder-minus:before{content:"\e932"}.mif-folder-download:before{content:"\e933"}.mif-folder-upload:before{content:"\e934"}.mif-tag:before{content:"\e935"}.mif-tags:before{content:"\e936"}.mif-barcode:before{content:"\e937"}.mif-qrcode:before{content:"\e938"}.mif-cart:before{content:"\e93a"}.mif-credit-card:before{content:"\e93f"}.mif-calculator:before{content:"\e940"}.mif-help:before{content:"\e941"}.mif-phone:before{content:"\e942"}.mif-envelop:before{content:"\e945"}.mif-location:before{content:"\e948"}.mif-compass:before{content:"\e949"}.mif-compass2:before{content:"\e94a"}.mif-map:before{content:"\e94b"}.mif-history:before{content:"\e94d"}.mif-calendar:before{content:"\e953"}.mif-printer:before{content:"\e954"}.mif-keyboard:before{content:"\e955"}.mif-display:before{content:"\e956"}.mif-laptop:before{content:"\e957"}.mif-mobile:before{content:"\e959"}.mif-tablet:before{content:"\e95a"}.mif-download:before{content:"\e960"}.mif-upload:before{content:"\e961"}.mif-floppy-disk:before{content:"\e962"}.mif-drive1:before{content:"\e963"}.mif-undo:before{content:"\e965"}.mif-redo:before{content:"\e966"}.mif-bubble:before{content:"\e96b"}.mif-bubbles:before{content:"\e96c"}.mif-user:before{content:"\e971"}.mif-users:before{content:"\e972"}.mif-user-plus:before{content:"\e973"}.mif-user-minus:before{content:"\e974"}.mif-user-check:before{content:"\e975"}.mif-hour-glass:before{content:"\e979"}.mif-spinner:before{content:"\e97a"}.mif-spinner1:before{content:"\e97b"}.mif-spinner2:before{content:"\e97d"}.mif-spinner3:before{content:"\e981"}.mif-spinner4:before{content:"\e982"}.mif-spinner5:before{content:"\e983"}.mif-search:before{content:"\e986"}.mif-zoom-in:before{content:"\e987"}.mif-zoom-out:before{content:"\e988"}.mif-enlarge:before{content:"\e989"}.mif-shrink:before{content:"\e98a"}.mif-enlarge2:before{content:"\e98b"}.mif-shrink2:before{content:"\e98c"}.mif-key:before{content:"\e98d"}.mif-wrench:before{content:"\e991"}.mif-equalizer:before{content:"\e992"}.mif-equalizer-v:before{content:"\e993"}.mif-cog:before{content:"\e994"}.mif-cogs:before{content:"\e995"}.mif-magic-wand:before{content:"\e997"}.mif-bug:before{content:"\e999"}.mif-chart-pie:before{content:"\e99a"}.mif-chart-dots:before{content:"\e99b"}.mif-chart-bars:before{content:"\e99c"}.mif-chart-bars2:before{content:"\e99d"}.mif-trophy:before{content:"\e99e"}.mif-gift:before{content:"\e99f"}.mif-spoon-fork:before{content:"\e9a3"}.mif-rocket:before{content:"\e9a5"}.mif-meter:before{content:"\e9a6"}.mif-hammer:before{content:"\e9a8"}.mif-fire:before{content:"\e9a9"}.mif-lab:before{content:"\e9aa"}.mif-bin:before{content:"\e9ac"}.mif-truck:before{content:"\e9b0"}.mif-target:before{content:"\e9b3"}.mif-switch:before{content:"\e9b6"}.mif-power-cord:before{content:"\e9b7"}.mif-clipboard:before{content:"\e9b8"}.mif-list-numbered:before{content:"\e9b9"}.mif-list:before{content:"\e9ba"}.mif-list2:before{content:"\e9bb"}.mif-tree:before{content:"\e9bc"}.mif-cloud:before{content:"\e9c1"}.mif-cloud-download:before{content:"\e9c2"}.mif-cloud-upload:before{content:"\e9c3"}.mif-download2:before{content:"\e9c7"}.mif-upload2:before{content:"\e9c8"}.mif-earth:before{content:"\e9ca"}.mif-link:before{content:"\e9cb"}.mif-flag:before{content:"\e9cc"}.mif-attachment:before{content:"\e9cd"}.mif-eye:before{content:"\e9ce"}.mif-bookmark:before{content:"\e9d2"}.mif-bookmarks:before{content:"\e9d3"}.mif-contrast:before{content:"\e9d5"}.mif-brightness:before{content:"\e9d6"}.mif-star-empty:before{content:"\e9d7"}.mif-star-half:before{content:"\e9d8"}.mif-star-full:before{content:"\e9d9"}.mif-heart:before{content:"\e9da"}.mif-heart-broken:before{content:"\e9db"}.mif-warning:before{content:"\ea07"}.mif-plus:before{content:"\ea0a"}.mif-minus:before{content:"\ea0b"}.mif-cancel:before{content:"\ea0d"}.mif-cross:before{content:"\ea0f"}.mif-checkmark:before{content:"\ea10"}.mif-spell-check:before{content:"\ea12"}.mif-enter:before{content:"\ea13"}.mif-exit:before{content:"\ea14"}.mif-play:before{content:"\ea1c"}.mif-pause:before{content:"\ea1d"}.mif-stop:before{content:"\ea1e"}.mif-backward:before{content:"\ea1f"}.mif-forward:before{content:"\ea20"}.mif-first:before{content:"\ea21"}.mif-last:before{content:"\ea22"}.mif-previous:before{content:"\ea23"}.mif-next:before{content:"\ea24"}.mif-eject:before{content:"\ea25"}.mif-volume-high:before{content:"\ea26"}.mif-volume-medium:before{content:"\ea27"}.mif-volume-low:before{content:"\ea28"}.mif-volume-mute:before{content:"\ea29"}.mif-volume-mute2:before{content:"\ea2a"}.mif-volume-plus:before{content:"\ea2b"}.mif-volume-minus:before{content:"\ea2c"}.mif-loop:before{content:"\ea2d"}.mif-loop2:before{content:"\ea2e"}.mif-infinite:before{content:"\ea2f"}.mif-shuffle:before{content:"\ea30"}.mif-arrow-up-left:before{content:"\ea39"}.mif-arrow-up:before{content:"\ea3a"}.mif-arrow-up-right:before{content:"\ea3b"}.mif-arrow-right:before{content:"\ea3c"}.mif-arrow-down-right:before{content:"\ea3d"}.mif-arrow-down:before{content:"\ea3e"}.mif-arrow-down-left:before{content:"\ea3f"}.mif-arrow-left:before{content:"\ea40"}.mif-tab:before{content:"\ea45"}.mif-move-up:before{content:"\ea46"}.mif-move-down:before{content:"\ea47"}.mif-sort-asc:before{content:"\ea4c"}.mif-sort-desc:before{content:"\ea4d"}.mif-command:before{content:"\ea4e"}.mif-shift:before{content:"\ea4f"}.mif-crop:before{content:"\ea57"}.mif-filter:before{content:"\ea5b"}.mif-bold:before{content:"\ea62"}.mif-underline:before{content:"\ea63"}.mif-italic:before{content:"\ea64"}.mif-strikethrough:before{content:"\ea65"}.mif-page-break:before{content:"\ea68"}.mif-superscript:before{content:"\ea69"}.mif-subscript:before{content:"\ea6a"}.mif-table:before{content:"\ea71"}.mif-insert-template:before{content:"\ea72"}.mif-pilcrow:before{content:"\ea73"}.mif-section:before{content:"\ea76"}.mif-paragraph-left:before{content:"\ea77"}.mif-paragraph-center:before{content:"\ea78"}.mif-paragraph-right:before{content:"\ea79"}.mif-paragraph-justify:before{content:"\ea7a"}.mif-indent-increase:before{content:"\ea7b"}.mif-indent-decrease:before{content:"\ea7c"}.mif-share:before{content:"\ea82"}.mif-google:before{content:"\ea87"}.mif-facebook2:before{content:"\ea8d"}.mif-twitter:before{content:"\ea91"}.mif-feed3:before{content:"\ea95"}.mif-youtube:before{content:"\ea99"}.mif-steam2:before{content:"\eaae"}.mif-onedrive:before{content:"\eab0"}.mif-git:before{content:"\eab5"}.mif-apple:before{content:"\eabf"}.mif-android:before{content:"\eac1"}.mif-windows:before{content:"\eac3"}.mif-skype:before{content:"\eac6"}.mif-linkedin:before{content:"\eac8"}.mif-chrome:before{content:"\eae5"}.mif-firefox:before{content:"\eae6"}.mif-ie:before{content:"\eae7"}.mif-opera:before{content:"\eae8"}.mif-safari:before{content:"\eae9"}.mif-airplane:before{content:"\e6c3"}.mif-instagram:before{content:"\e6c5"}.mif-twitch:before{content:"\e6c6"}.mif-picassa:before{content:"\e6c7"}.mif-deviantart:before{content:"\e6c8"}.mif-wordpress:before{content:"\e6c9"}.mif-joomla:before{content:"\e6ca"}.mif-blogger:before{content:"\e6cb"}.mif-tux:before{content:"\e6cc"}.mif-finder:before{content:"\e6cd"}.mif-soundcloud:before{content:"\e6ce"}.mif-reddit:before{content:"\e6cf"}.mif-delicious:before{content:"\e6d0"}.mif-stackoverflow:before{content:"\e6d1"}.mif-flattr:before{content:"\e6d2"}.mif-foursquare:before{content:"\e6d3"}.mif-file-openoffice:before{content:"\e6d4"}.mif-libreoffice:before{content:"\e6d5"}.mif-codepen:before{content:"\e6d6"}.mif-IcoMoon:before{content:"\e6d7"} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json deleted file mode 100644 index 021eac5..0000000 --- a/package-lock.json +++ /dev/null @@ -1,1036 +0,0 @@ -{ - "name": "pandora", - "version": "1.0.0", - "lockfileVersion": 3, - "requires": true, - "packages": { - "": { - "name": "pandora", - "version": "1.0.0", - "license": "ISC", - "dependencies": { - "axios": "^1.18.1", - "dotenv": "^17.4.2", - "express": "^5.2.1" - } - }, - "node_modules/accepts": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz", - "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==", - "license": "MIT", - "dependencies": { - "mime-types": "^3.0.0", - "negotiator": "^1.0.0" - }, - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/agent-base": { - "version": "6.0.2", - "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", - "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", - "license": "MIT", - "dependencies": { - "debug": "4" - }, - "engines": { - "node": ">= 6.0.0" - } - }, - "node_modules/asynckit": { - "version": "0.4.0", - "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", - "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", - "license": "MIT" - }, - "node_modules/axios": { - "version": "1.18.1", - "resolved": "https://registry.npmjs.org/axios/-/axios-1.18.1.tgz", - "integrity": "sha512-3nTvFlvpn9Zu/RkHUqtc7/+al4UpRW5az71ap5zccp6e8RAYEzhMTecX8Dz1wWDYrPpUoB1HAQEGEAEvUr7S9g==", - "license": "MIT", - "dependencies": { - "follow-redirects": "^1.16.0", - "form-data": "^4.0.5", - "https-proxy-agent": "^5.0.1", - "proxy-from-env": "^2.1.0" - } - }, - "node_modules/body-parser": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.3.0.tgz", - "integrity": "sha512-2cGmJupaNgg+QUwVLAucDuWuoMZ6EX9iHDRswZ5lsNYEmwPaRknMPCLZz07yTzVq/83p4o/wzbDZbBrTvGGTIw==", - "license": "MIT", - "dependencies": { - "bytes": "^3.1.2", - "content-type": "^2.0.0", - "debug": "^4.4.3", - "http-errors": "^2.0.1", - "iconv-lite": "^0.7.2", - "on-finished": "^2.4.1", - "qs": "^6.15.2", - "raw-body": "^3.0.2", - "type-is": "^2.1.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/body-parser/node_modules/content-type": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/content-type/-/content-type-2.0.0.tgz", - "integrity": "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==", - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/bytes": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", - "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/call-bind-apply-helpers": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", - "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", - "license": "MIT", - "dependencies": { - "es-errors": "^1.3.0", - "function-bind": "^1.1.2" - }, - "engines": { - "node": ">= 0.4" - } - }, - "node_modules/call-bound": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", - "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", - "license": "MIT", - "dependencies": { - "call-bind-apply-helpers": "^1.0.2", - "get-intrinsic": "^1.3.0" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/combined-stream": { - "version": "1.0.8", - "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", - "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", - "license": "MIT", - "dependencies": { - "delayed-stream": "~1.0.0" - }, - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/content-disposition": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.1.0.tgz", - "integrity": "sha512-5jRCH9Z/+DRP7rkvY83B+yGIGX96OYdJmzngqnw2SBSxqCFPd0w2km3s5iawpGX8krnwSGmF0FW5Nhr0Hfai3g==", - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/content-type": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", - "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/cookie": { - "version": "0.7.2", - "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", - "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/cookie-signature": { - "version": "1.2.2", - "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz", - "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==", - "license": "MIT", - "engines": { - "node": ">=6.6.0" - } - }, - "node_modules/debug": { - "version": "4.4.3", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", - "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", - "license": "MIT", - "dependencies": { - "ms": "^2.1.3" - }, - "engines": { - "node": ">=6.0" - }, - "peerDependenciesMeta": { - "supports-color": { - "optional": true - } - } - }, - "node_modules/delayed-stream": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", - "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", - "license": "MIT", - "engines": { - "node": ">=0.4.0" - } - }, - "node_modules/depd": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", - "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/dotenv": { - "version": "17.4.2", - "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-17.4.2.tgz", - "integrity": "sha512-nI4U3TottKAcAD9LLud4Cb7b2QztQMUEfHbvhTH09bqXTxnSie8WnjPALV/WMCrJZ6UV/qHJ6L03OqO3LcdYZw==", - "license": "BSD-2-Clause", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://dotenvx.com" - } - }, - "node_modules/dunder-proto": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", - "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", - "license": "MIT", - "dependencies": { - "call-bind-apply-helpers": "^1.0.1", - "es-errors": "^1.3.0", - "gopd": "^1.2.0" - }, - "engines": { - "node": ">= 0.4" - } - }, - "node_modules/ee-first": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", - "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==", - "license": "MIT" - }, - "node_modules/encodeurl": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", - "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/es-define-property": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", - "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", - "license": "MIT", - "engines": { - "node": ">= 0.4" - } - }, - "node_modules/es-errors": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", - "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", - "license": "MIT", - "engines": { - "node": ">= 0.4" - } - }, - "node_modules/es-object-atoms": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz", - "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==", - "license": "MIT", - "dependencies": { - "es-errors": "^1.3.0" - }, - "engines": { - "node": ">= 0.4" - } - }, - "node_modules/es-set-tostringtag": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", - "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==", - "license": "MIT", - "dependencies": { - "es-errors": "^1.3.0", - "get-intrinsic": "^1.2.6", - "has-tostringtag": "^1.0.2", - "hasown": "^2.0.2" - }, - "engines": { - "node": ">= 0.4" - } - }, - "node_modules/escape-html": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", - "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==", - "license": "MIT" - }, - "node_modules/etag": { - "version": "1.8.1", - "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", - "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/express": { - "version": "5.2.1", - "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz", - "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==", - "license": "MIT", - "dependencies": { - "accepts": "^2.0.0", - "body-parser": "^2.2.1", - "content-disposition": "^1.0.0", - "content-type": "^1.0.5", - "cookie": "^0.7.1", - "cookie-signature": "^1.2.1", - "debug": "^4.4.0", - "depd": "^2.0.0", - "encodeurl": "^2.0.0", - "escape-html": "^1.0.3", - "etag": "^1.8.1", - "finalhandler": "^2.1.0", - "fresh": "^2.0.0", - "http-errors": "^2.0.0", - "merge-descriptors": "^2.0.0", - "mime-types": "^3.0.0", - "on-finished": "^2.4.1", - "once": "^1.4.0", - "parseurl": "^1.3.3", - "proxy-addr": "^2.0.7", - "qs": "^6.14.0", - "range-parser": "^1.2.1", - "router": "^2.2.0", - "send": "^1.1.0", - "serve-static": "^2.2.0", - "statuses": "^2.0.1", - "type-is": "^2.0.1", - "vary": "^1.1.2" - }, - "engines": { - "node": ">= 18" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/finalhandler": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.1.tgz", - "integrity": "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==", - "license": "MIT", - "dependencies": { - "debug": "^4.4.0", - "encodeurl": "^2.0.0", - "escape-html": "^1.0.3", - "on-finished": "^2.4.1", - "parseurl": "^1.3.3", - "statuses": "^2.0.1" - }, - "engines": { - "node": ">= 18.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/follow-redirects": { - "version": "1.16.0", - "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.16.0.tgz", - "integrity": "sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==", - "funding": [ - { - "type": "individual", - "url": "https://github.com/sponsors/RubenVerborgh" - } - ], - "license": "MIT", - "engines": { - "node": ">=4.0" - }, - "peerDependenciesMeta": { - "debug": { - "optional": true - } - } - }, - "node_modules/form-data": { - "version": "4.0.6", - "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.6.tgz", - "integrity": "sha512-vKatAh4SlVfgbv+YtmhiRjhEMJsYpsG1Y2rMQtR+SVSbytsSD1YGzDIcrAJmdFec88u/+VoGmxnl+80gL1tRCQ==", - "license": "MIT", - "dependencies": { - "asynckit": "^0.4.0", - "combined-stream": "^1.0.8", - "es-set-tostringtag": "^2.1.0", - "hasown": "^2.0.4", - "mime-types": "^2.1.35" - }, - "engines": { - "node": ">= 6" - } - }, - "node_modules/form-data/node_modules/mime-db": { - "version": "1.52.0", - "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", - "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/form-data/node_modules/mime-types": { - "version": "2.1.35", - "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", - "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", - "license": "MIT", - "dependencies": { - "mime-db": "1.52.0" - }, - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/forwarded": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", - "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/fresh": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz", - "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/function-bind": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", - "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", - "license": "MIT", - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/get-intrinsic": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", - "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", - "license": "MIT", - "dependencies": { - "call-bind-apply-helpers": "^1.0.2", - "es-define-property": "^1.0.1", - "es-errors": "^1.3.0", - "es-object-atoms": "^1.1.1", - "function-bind": "^1.1.2", - "get-proto": "^1.0.1", - "gopd": "^1.2.0", - "has-symbols": "^1.1.0", - "hasown": "^2.0.2", - "math-intrinsics": "^1.1.0" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/get-proto": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", - "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", - "license": "MIT", - "dependencies": { - "dunder-proto": "^1.0.1", - "es-object-atoms": "^1.0.0" - }, - "engines": { - "node": ">= 0.4" - } - }, - "node_modules/gopd": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", - "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", - "license": "MIT", - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/has-symbols": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", - "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", - "license": "MIT", - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/has-tostringtag": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", - "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", - "license": "MIT", - "dependencies": { - "has-symbols": "^1.0.3" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/hasown": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz", - "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==", - "license": "MIT", - "dependencies": { - "function-bind": "^1.1.2" - }, - "engines": { - "node": ">= 0.4" - } - }, - "node_modules/http-errors": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", - "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", - "license": "MIT", - "dependencies": { - "depd": "~2.0.0", - "inherits": "~2.0.4", - "setprototypeof": "~1.2.0", - "statuses": "~2.0.2", - "toidentifier": "~1.0.1" - }, - "engines": { - "node": ">= 0.8" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/https-proxy-agent": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", - "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", - "license": "MIT", - "dependencies": { - "agent-base": "6", - "debug": "4" - }, - "engines": { - "node": ">= 6" - } - }, - "node_modules/iconv-lite": { - "version": "0.7.3", - "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.3.tgz", - "integrity": "sha512-IKXpvIzjnC9XTAUbVBcMfGS0EPaIXtW6v+zr+RRp+hqULEpo0owZax6wyRwPOJbWbzjYspQwusTsfVr0ifh4uQ==", - "license": "MIT", - "dependencies": { - "safer-buffer": ">= 2.1.2 < 3.0.0" - }, - "engines": { - "node": ">=0.10.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/inherits": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", - "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", - "license": "ISC" - }, - "node_modules/ipaddr.js": { - "version": "1.9.1", - "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", - "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", - "license": "MIT", - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/is-promise": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz", - "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==", - "license": "MIT" - }, - "node_modules/math-intrinsics": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", - "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", - "license": "MIT", - "engines": { - "node": ">= 0.4" - } - }, - "node_modules/media-typer": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz", - "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/merge-descriptors": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz", - "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==", - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/mime-db": { - "version": "1.54.0", - "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz", - "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/mime-types": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.2.tgz", - "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==", - "license": "MIT", - "dependencies": { - "mime-db": "^1.54.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/ms": { - "version": "2.1.3", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", - "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", - "license": "MIT" - }, - "node_modules/negotiator": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz", - "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/object-inspect": { - "version": "1.13.4", - "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", - "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", - "license": "MIT", - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/on-finished": { - "version": "2.4.1", - "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", - "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", - "license": "MIT", - "dependencies": { - "ee-first": "1.1.1" - }, - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/once": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", - "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", - "license": "ISC", - "dependencies": { - "wrappy": "1" - } - }, - "node_modules/parseurl": { - "version": "1.3.3", - "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", - "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/path-to-regexp": { - "version": "8.4.2", - "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.4.2.tgz", - "integrity": "sha512-qRcuIdP69NPm4qbACK+aDogI5CBDMi1jKe0ry5rSQJz8JVLsC7jV8XpiJjGRLLol3N+R5ihGYcrPLTno6pAdBA==", - "license": "MIT", - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/proxy-addr": { - "version": "2.0.7", - "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", - "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", - "license": "MIT", - "dependencies": { - "forwarded": "0.2.0", - "ipaddr.js": "1.9.1" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/proxy-from-env": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-2.1.0.tgz", - "integrity": "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==", - "license": "MIT", - "engines": { - "node": ">=10" - } - }, - "node_modules/qs": { - "version": "6.15.3", - "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.3.tgz", - "integrity": "sha512-O9gl3zCl5h5blw1KGUzQKhA5oUXSl8rwUIM5o0S3nCXMliSvy5Dzx7/DJcI+SwgICv+IneSZwhBh1oSyEHA71A==", - "license": "BSD-3-Clause", - "dependencies": { - "es-define-property": "^1.0.1", - "side-channel": "^1.1.1" - }, - "engines": { - "node": ">=0.6" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/range-parser": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.3.0.tgz", - "integrity": "sha512-hek2mFQpPuI4E1BBKrSto+BU3e3x4xuarsbiwr3+lf7p44juvFMV0XFWQAP3xUyqXA4RrXLIoaSUGbSt056ZMw==", - "license": "MIT", - "engines": { - "node": ">= 0.6" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/raw-body": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.2.tgz", - "integrity": "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==", - "license": "MIT", - "dependencies": { - "bytes": "~3.1.2", - "http-errors": "~2.0.1", - "iconv-lite": "~0.7.0", - "unpipe": "~1.0.0" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/router": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz", - "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==", - "license": "MIT", - "dependencies": { - "debug": "^4.4.0", - "depd": "^2.0.0", - "is-promise": "^4.0.0", - "parseurl": "^1.3.3", - "path-to-regexp": "^8.0.0" - }, - "engines": { - "node": ">= 18" - } - }, - "node_modules/safer-buffer": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", - "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", - "license": "MIT" - }, - "node_modules/send": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/send/-/send-1.2.1.tgz", - "integrity": "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==", - "license": "MIT", - "dependencies": { - "debug": "^4.4.3", - "encodeurl": "^2.0.0", - "escape-html": "^1.0.3", - "etag": "^1.8.1", - "fresh": "^2.0.0", - "http-errors": "^2.0.1", - "mime-types": "^3.0.2", - "ms": "^2.1.3", - "on-finished": "^2.4.1", - "range-parser": "^1.2.1", - "statuses": "^2.0.2" - }, - "engines": { - "node": ">= 18" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/serve-static": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.1.tgz", - "integrity": "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==", - "license": "MIT", - "dependencies": { - "encodeurl": "^2.0.0", - "escape-html": "^1.0.3", - "parseurl": "^1.3.3", - "send": "^1.2.0" - }, - "engines": { - "node": ">= 18" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/setprototypeof": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", - "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", - "license": "ISC" - }, - "node_modules/side-channel": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.1.tgz", - "integrity": "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==", - "license": "MIT", - "dependencies": { - "es-errors": "^1.3.0", - "object-inspect": "^1.13.4", - "side-channel-list": "^1.0.1", - "side-channel-map": "^1.0.1", - "side-channel-weakmap": "^1.0.2" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/side-channel-list": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz", - "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==", - "license": "MIT", - "dependencies": { - "es-errors": "^1.3.0", - "object-inspect": "^1.13.4" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/side-channel-map": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", - "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", - "license": "MIT", - "dependencies": { - "call-bound": "^1.0.2", - "es-errors": "^1.3.0", - "get-intrinsic": "^1.2.5", - "object-inspect": "^1.13.3" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/side-channel-weakmap": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", - "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", - "license": "MIT", - "dependencies": { - "call-bound": "^1.0.2", - "es-errors": "^1.3.0", - "get-intrinsic": "^1.2.5", - "object-inspect": "^1.13.3", - "side-channel-map": "^1.0.1" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/statuses": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", - "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/toidentifier": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", - "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", - "license": "MIT", - "engines": { - "node": ">=0.6" - } - }, - "node_modules/type-is": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.1.0.tgz", - "integrity": "sha512-faYHw0anBbc/kWF3zFTEnxSFOAGUX9GFbOBthvDdLsIlEoWOFOtS0zgCiQYwIskL9iGXZL3kAXD8OoZ4GmMATA==", - "license": "MIT", - "dependencies": { - "content-type": "^2.0.0", - "media-typer": "^1.1.0", - "mime-types": "^3.0.0" - }, - "engines": { - "node": ">= 18" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/type-is/node_modules/content-type": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/content-type/-/content-type-2.0.0.tgz", - "integrity": "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==", - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/unpipe": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", - "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/vary": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", - "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/wrappy": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", - "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", - "license": "ISC" - } - } -} diff --git a/package.json b/package.json deleted file mode 100644 index c71df44..0000000 --- a/package.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "name": "pandora", - "version": "1.0.0", - "type": "module", - "main": "index.js", - "scripts": { - "start": "node index.js", - "test": "echo \"Error: no test specified\" && exit 1" - }, - "keywords": [], - "author": "", - "license": "ISC", - "description": "", - "dependencies": { - "axios": "^1.18.1", - "dotenv": "^17.4.2", - "express": "^5.2.1" - } -} diff --git a/public/app.js b/public/app.js deleted file mode 100644 index 8e2ebfb..0000000 --- a/public/app.js +++ /dev/null @@ -1,263 +0,0 @@ -import { config } from "./config.js"; -import { waha } from "./waha.js"; -import { ui, elements } from "./ui.js"; -import { websocket } from "./websocket.js"; -import { compensateMessageOrdering, formatTime } from "./utils.js"; - -let chatsState = []; -let activeChatState = null; - -// Initialize app when DOM is ready -document.addEventListener('DOMContentLoaded', () => { - setupEventListeners(); - fetchChats(); - checkWahaStatus(); - initWebSocket(); -}); - -function setupEventListeners() { - elements.refreshChatsBtn.addEventListener('click', () => { - elements.refreshChatsBtn.classList.add('spinning'); - fetchChats().finally(() => { - setTimeout(() => { - elements.refreshChatsBtn.classList.remove('spinning'); - }, 600); - }); - }); - - elements.chatSearch.addEventListener('input', (e) => { - const query = e.target.value.toLowerCase(); - const filtered = chatsState.filter(chat => - chat.name.toLowerCase().includes(query) - ); - ui.renderChatList(filtered, activeChatState, selectChat); - }); - - elements.messageForm.addEventListener('submit', (e) => { - e.preventDefault(); - sendMessage(); - }); - - elements.backToSidebarBtn.addEventListener('click', () => { - elements.sidebar.classList.remove('hidden'); - elements.activeChatContainer.classList.add('hidden'); - }); - - elements.settingsIconBtn.addEventListener('click', openSettings); - elements.closeSettingsBtn.addEventListener('click', () => ui.toggleModal(false)); - elements.cancelSettingsBtn.addEventListener('click', () => ui.toggleModal(false)); - elements.saveSettingsBtn.addEventListener('click', saveSettings); -} - -function initWebSocket() { - websocket.connect((data) => { - console.log('[WS] Received event:', data.event, data); - const ev = data.event; - if (ev === 'message' || ev === 'message.any' || ev === 'message.ack') { - handleIncomingMessage(data.payload); - } - }); -} - -function normalizeChatId(raw) { - if (!raw) return null; - if (typeof raw === 'object') { - return raw._serialized || raw.user || JSON.stringify(raw); - } - return raw; -} - -function handleIncomingMessage(msg) { - if (!msg) return; - - console.log('[WS] handleIncomingMessage payload:', msg); - - const rawChatId = msg.chatId || msg.from || (msg.chat && msg.chat.id); - const msgChatId = normalizeChatId(rawChatId); - if (!msgChatId) { - console.warn('[WS] Could not resolve chatId from payload:', msg); - return; - } - - console.log('[WS] Resolved msgChatId:', msgChatId, '| activeChatState:', activeChatState?.id); - - if (activeChatState && activeChatState.id === msgChatId) { - const msgId = normalizeChatId(msg.id) || msg.id; - const exists = document.getElementById(msgId); - if (!exists) { - ui.appendSingleMessage({ ...msg, chatId: msgChatId }, activeChatState.name); - ui.scrollToBottom(); - } - } - - const chatIndex = chatsState.findIndex(c => c.id === msgChatId); - if (chatIndex !== -1) { - const chat = chatsState[chatIndex]; - chat.lastMessage = msg.body || msg.text || 'Media message'; - chat.timestamp = msg.timestamp ? (msg.timestamp * 1000) : Date.now(); - - if (!msg.fromMe && (!activeChatState || activeChatState.id !== msgChatId)) { - chat.unreadCount = (chat.unreadCount || 0) + 1; - } - - chatsState.sort((a, b) => { - const tA = new Date(a.timestamp).getTime(); - const tB = new Date(b.timestamp).getTime(); - return tB - tA; - }); - - ui.renderChatList(chatsState, activeChatState, selectChat); - } else { - fetchChats(); - } -} - -async function fetchChats() { - const userInfo = await waha.getMyInfo(); - elements.loggedUserName.textContent = userInfo.pushName; - elements.userIcon.innerText = userInfo.pushName[0]; - elements.chatsLoader.classList.remove('hidden'); - try { - chatsState = await waha.getChats(); - ui.renderChatList(chatsState, activeChatState, selectChat); - } catch (error) { - console.error('Failed to load chats:', error); - elements.chatList.innerHTML = ` -
  • -

    Connection to WAHA failed.

    -

    - Ensure WAHA server is running and CORS is enabled, or click Settings to configure. -

    -
    • - `; - } finally { - elements.chatsLoader.classList.add('hidden'); - } -} - -async function selectChat(chat) { - activeChatState = chat; - - chat.unreadCount = 0; - - ui.renderChatList(chatsState, activeChatState, selectChat); - - ui.toggleChatState(true); - elements.activeChatName.textContent = chat.name; - elements.activeChatAvatar.textContent = chat.name ? chat.name.substring(0, 1).toUpperCase() : '?'; - - elements.messagesContainer.innerHTML = '
    Loading messages...
    '; - - if (window.innerWidth <= 768) { - elements.sidebar.classList.add('hidden'); - } - - try { - const rawMessages = await waha.getChatMessages(chat.id); - const processedMessages = compensateMessageOrdering(rawMessages); - ui.renderMessages(processedMessages, chat.name); - } catch (error) { - console.error('Failed to load messages:', error); - elements.messagesContainer.innerHTML = '
    Error loading messages
    '; - } -} - -async function sendMessage() { - const text = elements.messageInput.value.trim(); - if (!text || !activeChatState) return; - - elements.messageInput.value = ''; - - const tempMsg = { - id: 'temp-' + Date.now(), - body: text, - fromMe: true, - sender: 'me', - timestamp: new Date().toISOString(), - status: 'sending' - }; - - ui.appendSingleMessage(tempMsg, activeChatState.name); - ui.scrollToBottom(); - - try { - try { - await waha.startTyping(activeChatState.id); - const delay = Math.min(4000, Math.max(1000, text.length * 50)); - await new Promise(resolve => setTimeout(resolve, delay)); - } catch (e) { - console.warn('Presence start failed:', e); - } - - try { - await waha.stopTyping(activeChatState.id); - } catch (e) { - console.warn('Presence stop failed:', e); - } - - try { - if (!activeChatState.id.endsWith('@lid')) { - await waha.readChat(activeChatState.id); - } - } catch (e) { - console.warn('readChat failed (non-fatal):', e.message); - } - - const responseData = await waha.sendTextMessage(activeChatState.id, text); - - const tempBubble = document.getElementById(tempMsg.id); - if (tempBubble) { - if (responseData && responseData.id) { - tempBubble.id = responseData.id; - } - const meta = tempBubble.querySelector('.message-meta'); - meta.innerHTML = `${formatTime(new Date())}`; - lucide.createIcons(); - } - - activeChatState.lastMessage = text; - activeChatState.timestamp = new Date(); - - chatsState.sort((a, b) => { - const tA = new Date(a.timestamp).getTime(); - const tB = new Date(b.timestamp).getTime(); - return tB - tA; - }); - ui.renderChatList(chatsState, activeChatState, selectChat); - } catch (error) { - console.error('Failed to send message:', error); - const tempBubble = document.getElementById(tempMsg.id); - if (tempBubble) { - const meta = tempBubble.querySelector('.message-meta'); - meta.innerHTML = `Failed to send`; - } - } -} - -function openSettings() { - elements.inputWahaUrl.value = config.wahaUrl; - elements.inputSession.value = config.session; - elements.inputApiKey.value = config.apiKey; - ui.toggleModal(true); -} - -function saveSettings() { - config.save( - elements.inputWahaUrl.value, - elements.inputSession.value, - elements.inputApiKey.value - ); - ui.toggleModal(false); - fetchChats(); - checkWahaStatus(); - initWebSocket(); -} - -async function checkWahaStatus() { - try { - const data = await waha.getVersion(); - ui.updateConnectionStatus(true, `WAHA Connected: v${data.version || 'OK'}`); - } catch (e) { - ui.updateConnectionStatus(false, 'WAHA Server Offline'); - } -} diff --git a/public/index.html b/public/index.html deleted file mode 100644 index eb79442..0000000 --- a/public/index.html +++ /dev/null @@ -1,147 +0,0 @@ - - - - - - Pandora - - - - - - - -
    - - - - -
    - -
    -
    -
    - -
    -

    Welcome to Pandora Chat

    -

    Select a contact from the sidebar to view the conversation or start a new chat. Your chats are synced directly with the WAHA API backend.

    -
    -
    - - - -
    -
    - - - - - - - - diff --git a/public/ui.js b/public/ui.js deleted file mode 100644 index 70f9e39..0000000 --- a/public/ui.js +++ /dev/null @@ -1,198 +0,0 @@ -import { formatTime } from "./utils.js"; - -// DOM Selector Cache -export const elements = { - chatList: document.getElementById('chat-list'), - chatsLoader: document.getElementById('chats-loader'), - chatCountBadge: document.getElementById('chat-count'), - chatSearch: document.getElementById('chat-search'), - refreshChatsBtn: document.getElementById('refresh-chats-btn'), - backendStatusText: document.getElementById('backend-status-text'), - apiStatusIndicator: document.querySelector('.pulse-dot'), - noChatState: document.getElementById('no-chat-state'), - activeChatContainer: document.getElementById('active-chat-container'), - activeChatName: document.getElementById('active-chat-name'), - activeChatAvatar: document.getElementById('active-chat-avatar'), - messagesContainer: document.getElementById('messages-container'), - messageForm: document.getElementById('message-form'), - messageInput: document.getElementById('message-input'), - backToSidebarBtn: document.getElementById('back-to-sidebar'), - sidebar: document.querySelector('.sidebar'), - settingsModal: document.getElementById('settings-modal'), - settingsIconBtn: document.querySelector('.header-actions button[title="Settings"]'), - closeSettingsBtn: document.getElementById('close-settings'), - cancelSettingsBtn: document.getElementById('cancel-settings'), - saveSettingsBtn: document.getElementById('save-settings'), - inputWahaUrl: document.getElementById('settings-waha-url'), - inputSession: document.getElementById('settings-session'), - inputApiKey: document.getElementById('settings-api-key'), - loggedUserName: document.getElementById('pandora-username'), - userIcon: document.getElementById('pandora-user-icon') -}; - -export const ui = { - /** - * Show or hide Settings connection modal - */ - toggleModal(show) { - if (show) { - elements.settingsModal.classList.remove('hidden'); - } else { - elements.settingsModal.classList.add('hidden'); - } - }, - - /** - * Switch view state when a contact chat is opened or closed - */ - toggleChatState(hasActive) { - if (hasActive) { - elements.noChatState.classList.add('hidden'); - elements.activeChatContainer.classList.remove('hidden'); - } else { - elements.noChatState.classList.remove('hidden'); - elements.activeChatContainer.classList.add('hidden'); - } - }, - - /** - * Scroll message list automatically to bottom - */ - scrollToBottom() { - elements.messagesContainer.scrollTop = elements.messagesContainer.scrollHeight; - }, - - /** - * Update connection status badge in sidebar footer - */ - updateConnectionStatus(isConnected, text) { - elements.backendStatusText.textContent = text; - if (isConnected) { - elements.apiStatusIndicator.style.backgroundColor = 'var(--online-color)'; - elements.apiStatusIndicator.style.animation = 'pulse 1.8s infinite'; - } else { - elements.apiStatusIndicator.style.backgroundColor = '#ef4444'; - elements.apiStatusIndicator.style.animation = 'none'; - } - }, - - /** - * Render sidebar contact chats list - */ - renderChatList(chats, activeChat, onChatSelect) { - elements.chatList.innerHTML = ''; - elements.chatCountBadge.textContent = chats.length; - - if (chats.length === 0) { - elements.chatList.innerHTML = `
  • No chats found
    • `; - return; - } - - chats.forEach(chat => { - const li = document.createElement('li'); - li.className = `chat-item ${activeChat && activeChat.id === chat.id ? 'active' : ''}`; - li.dataset.id = chat.id; - - const initials = chat.name ? chat.name.substring(0, 1).toUpperCase() : '?'; - const hasUnread = chat.unreadCount && chat.unreadCount > 0; - const timeStr = formatTime(chat.timestamp || new Date()); - - li.innerHTML = ` -
    ${initials}
    -
    -
    - ${chat.name} - ${timeStr} -
    -
    - ${chat.lastMessage || 'No messages yet'} - ${hasUnread ? `${chat.unreadCount}` : ''} -
    -
    - `; - - li.addEventListener('click', () => onChatSelect(chat)); - elements.chatList.appendChild(li); - }); - }, - - /** - * Render chat message log inside chat view container - */ - renderMessages(messages, activeChatName) { - elements.messagesContainer.innerHTML = ''; - - if (messages.length === 0) { - elements.messagesContainer.innerHTML = '
    No messages. Say hello!
    '; - return; - } - - messages.forEach(msg => { - const isOutgoing = msg.fromMe || msg.sender === 'me'; - const groupDiv = document.createElement('div'); - groupDiv.className = `message-group ${isOutgoing ? 'outgoing' : 'incoming'}`; - groupDiv.id = msg.id; - - const senderName = isOutgoing ? 'Me' : (msg.senderName || activeChatName); - const timeStr = formatTime(msg.timestamp || new Date()); - - let statusCheck = ''; - if (isOutgoing) { - if (msg.status === 'read') { - statusCheck = ''; - } else if (msg.status === 'delivered') { - statusCheck = ''; - } else { - statusCheck = ''; - } - } - - groupDiv.innerHTML = ` - ${!isOutgoing ? `${senderName}` : ''} -
    - ${msg.body || msg.text} -
    - ${timeStr} - ${statusCheck} -
    -
    - `; - - elements.messagesContainer.appendChild(groupDiv); - }); - - lucide.createIcons(); - this.scrollToBottom(); - }, - - /** - * Append a single message (used for optimistic updates immediately upon sending) - */ - appendSingleMessage(msg, activeChatName) { - if (elements.messagesContainer.querySelector('.loading-chats')) { - elements.messagesContainer.innerHTML = ''; - } - - const isOutgoing = msg.fromMe || msg.sender === 'me'; - const groupDiv = document.createElement('div'); - groupDiv.className = `message-group ${isOutgoing ? 'outgoing' : 'incoming'}`; - groupDiv.id = msg.id; - - const senderName = isOutgoing ? 'Me' : activeChatName; - const timeStr = formatTime(msg.timestamp || new Date()); - - groupDiv.innerHTML = ` - ${!isOutgoing ? `${senderName}` : ''} -
    - ${msg.body || msg.text} -
    - ${timeStr} - -
    -
    - `; - - elements.messagesContainer.appendChild(groupDiv); - lucide.createIcons(); - } -}; diff --git a/public/waha.js b/public/waha.js deleted file mode 100644 index 1413bc0..0000000 --- a/public/waha.js +++ /dev/null @@ -1,92 +0,0 @@ -import { config } from "./config.js"; - -async function request(path, options = {}) { - const url = `${config.wahaUrl}${path}`; - const headers = { - 'Content-Type': 'application/json', - 'accept': '*/*', - ...options.headers - }; - if (config.apiKey) { - headers['X-Api-Key'] = config.apiKey; - } - - console.log(`[WAHA] ${options.method || 'GET'} ${url}`, options.body ? JSON.parse(options.body) : ''); - - const response = await fetch(url, { ...options, headers }); - if (!response.ok) { - let errorDetail = ''; - try { - const errBody = await response.json(); - errorDetail = JSON.stringify(errBody); - console.error(`[WAHA] Error response body:`, errBody); - } catch (_) { - errorDetail = await response.text().catch(() => ''); - } - throw new Error(`WAHA API returned ${response.status}: ${response.statusText} — ${errorDetail}`); - } - return response.json(); -} - -export const waha = { - async getVersion() { - return request('/api/version'); - }, - - async getChats() { - const data = await request(`/api/${config.session}/chats`); - return data.map(chat => { - let chatId = chat.id; - if (chatId && typeof chatId === "object") { - chatId = chatId._serialized || chatId.user || JSON.stringify(chatId); - } - return { - id: chatId || chat.chatId || chat.name, - name: chat.name || "Unknown Contact", - unreadCount: chat.unreadCount || 0, - lastMessage: chat.lastMessage?.body || chat.lastMessageText || "Click to open chat", - timestamp: chat.lastMessage?.timestamp || new Date() - }; - }); - }, - - async getChatMessages(chatId) { - return request(`/api/${config.session}/chats/${chatId}/messages?downloadMedia=false&limit=40`); - }, - - async readChat(chatId) { - return request('/api/sendSeen', { - method: 'POST', - body: JSON.stringify({ chatId, session: config.session }) - }); - }, - - async getMyInfo() { - return request(`/api/sessions/${config.session}/me`); - }, - - async startTyping(chatId) { - return request('/api/startTyping', { - method: 'POST', - body: JSON.stringify({ chatId, session: config.session }) - }); - }, - - async stopTyping(chatId) { - return request('/api/stopTyping', { - method: 'POST', - body: JSON.stringify({ chatId, session: config.session }) - }); - }, - - async sendTextMessage(chatId, text) { - return request('/api/sendText', { - method: 'POST', - body: JSON.stringify({ - chatId, - text, - session: config.session - }) - }); - } -}; diff --git a/public/style.css b/style.css similarity index 52% rename from public/style.css rename to style.css index 820ea63..ddc4e0b 100644 --- a/public/style.css +++ b/style.css @@ -1,48 +1,142 @@ +@font-face { + font-family: Selawik; + src: url(./fonts/selawk.ttf); + font-weight: normal; +} + +@font-face { + font-family: Selawik; + src: url(./fonts/selawkl.ttf); + font-weight: 200; +} + +@font-face { + font-family: Selawik; + src: url(./fonts/selawksl.ttf); + font-weight: 300; +} + +@font-face { + font-family: Selawik; + src: url(./fonts/selawkb.ttf); + font-weight: bold; +} + +@font-face { + font-family: Selawik; + src: url(./fonts/selawkb.ttf); + font-weight: 800; +} + :root { - --bg-main: #090d16; - --sidebar-bg: rgba(17, 24, 39, 0.75); - --chat-bg: rgba(15, 23, 42, 0.6); + --bg-main: black; + --bg-secondary: #242424; + --sidebar-bg: black; + --chat-bg: black; --border-color: rgba(255, 255, 255, 0.08); --border-hover: rgba(255, 255, 255, 0.15); --text-primary: #f8fafc; --text-secondary: #94a3b8; - --text-muted: #64748b; - --accent: #6366f1; - --accent-gradient: linear-gradient(135deg, #6366f1 0%, #a855f7 100%); + --text-muted: rgb(134, 134, 134); + --accent: white; + --accent-gradient: black; --accent-hover: #4f46e5; - --online-color: #10b981; - --bubble-incoming: rgba(30, 41, 59, 0.85); - --bubble-outgoing: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%); - --input-bg: rgba(15, 23, 42, 0.8); + --online-color: rgba(255, 255, 255, 0.6); + --bubble-incoming: #01abaa; + --bubble-outgoing: #016f6e; + --input-bg: black; --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.05); --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06); --shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.3), 0 4px 6px -2px rgba(0, 0, 0, 0.1); --glass-blur: blur(20px); + --high-box-shadow: 2px 7px 5px rgba(0, 0, 0, 0.3), 0px -4px 10px rgba(0, 0, 0, 0.3); +} + +body.light { + --bg-main: white; + --bg-secondary: #F0F0F0; + --sidebar-bg: white; + --chat-bg: white; + --border-color: rgba(255, 255, 255, 0.08); + --border-hover: rgba(255, 255, 255, 0.15); + --text-primary: black; + --text-secondary: black; + --text-muted: rgb(134, 134, 134); + --accent: black; --accent-gradient: white; --accent-hover: #4f46e5; --online-color: rgba(0, 0, 000, 0.6); + --bubble-incoming: #01abaa; + --bubble-outgoing: #016f6e; + --input-bg: white; --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.05); + --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06); --shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.3), 0 4px 6px -2px rgba(0, 0, 0, 0.1); --glass-blur: blur(20px); + --high-box-shadow: 2px 7px 5px rgba(0, 0, 0, 0.3), 0px -4px 10px rgba(0, 0, 0, 0.3); } * { margin: 0; padding: 0; box-sizing: border-box; - font-family: 'Inter', -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; + font-family: Selawik, 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; + user-select: none; +} + +html, body { + margin: 0; + padding: 0; + width: 100%; + height: 100%; + height: 100dvh; + overflow: hidden; + position: fixed; + top: 0; + left: 0; } body { background-color: var(--bg-main); color: var(--text-primary); - height: 100vh; - overflow: hidden; background-image: - radial-gradient(at 0% 0%, rgba(99, 102, 241, 0.12) 0px, transparent 50%), - radial-gradient(at 100% 100%, rgba(168, 85, 247, 0.12) 0px, transparent 50%); + radial-gradient(at 0% 0%, rgba(99, 102, 241, 0.12) 0px, transparent 50%), + radial-gradient(at 100% 100%, rgba(168, 85, 247, 0.12) 0px, transparent 50%); +} + +a { + color: var(--text-primary); +} + +button { + background-color: var(--bg-main); + border: none; + color: var(--text-primary); + transition: .4s; +} + +button:hover { + color: var(--text-secondary); +} + +input { + background: var(--bg-secondary); + color: var(--accent); + border: none; + padding: 1em; + transition: .2s; +} + +input:focus { + background-color: var(--text-primary); + color: var(--bg-main); + outline: none; } .app-container { display: flex; - width: 100vw; - height: 100vh; + width: 100%; + height: 100%; overflow: hidden; - backdrop-filter: var(--glass-blur); + position: relative; +} + +.app-name { + font-weight: bold; } /* Sidebar Styling */ @@ -57,11 +151,14 @@ body { } .sidebar-header { - padding: 20px; + padding: 20px 20px 0px 20px; display: flex; - justify-content: space-between; - align-items: center; - border-bottom: 1px solid var(--border-color); + flex-direction: column; + align-items: self-start; +} + +#pandora-username { + font-size: xx-large; } .user-profile { @@ -73,7 +170,6 @@ body { .avatar { width: 44px; height: 44px; - border-radius: 12px; display: flex; align-items: center; justify-content: center; @@ -86,6 +182,10 @@ body { border: 1px solid rgba(255, 255, 255, 0.1); } +.avatar img { + max-width: 100%; +} + .user-avatar { background: linear-gradient(135deg, #10b981 0%, #059669 100%); } @@ -121,10 +221,9 @@ body { .icon-btn { width: 38px; height: 38px; - border-radius: 10px; - border: 1px solid var(--border-color); - background: rgba(255, 255, 255, 0.03); - color: var(--text-secondary); + border: none; + background: var(--bg-main); + color: var(--text-primary); display: flex; align-items: center; justify-content: center; @@ -136,13 +235,16 @@ body { background: rgba(255, 255, 255, 0.08); color: var(--text-primary); border-color: var(--border-hover); - transform: translateY(-1px); } .icon-btn:active { transform: translateY(0); } +.text-btn { + font-size: larger; +} + /* Search Bar */ .search-container { padding: 16px 20px; @@ -165,19 +267,18 @@ body { #chat-search { width: 100%; - padding: 12px 14px 12px 42px; - border-radius: 10px; - border: 1px solid var(--border-color); - background: rgba(15, 23, 42, 0.6); - color: var(--text-primary); + padding: 12px; + border: none; font-size: 0.9rem; transition: all 0.25s ease; + background-color: var(--bg-secondary); } #chat-search:focus { outline: none; border-color: var(--accent); - background: rgba(15, 23, 42, 0.9); + background: white; + color: var(--bg-main); box-shadow: 0 0 0 2px rgba(99, 102, 241, 0.2); } @@ -223,19 +324,24 @@ body { align-items: center; gap: 12px; padding: 12px; - border-radius: 12px; cursor: pointer; transition: all 0.2s ease; border: 1px solid transparent; } -.chat-item:hover { - background: rgba(255, 255, 255, 0.04); +.selected { + background: rgba(255, 255, 255, 0.04); + transform: scale(0.98) skewX(10deg); + filter: blur(.1px); + opacity: .6; } -.chat-item.active { - background: rgba(99, 102, 241, 0.15); - border-color: rgba(99, 102, 241, 0.25); + +.selectable:active { + background: rgba(255, 255, 255, 0.04); + transform: scale(0.98) skewX(10deg); + filter: blur(.1px); + opacity: .6; } .chat-item-info { @@ -274,16 +380,17 @@ body { .chat-item-msg { font-size: 0.82rem; - color: var(--text-secondary); + color: var(--accent); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; + font-weight: 300; flex: 1; } .chat-item .unread-badge { background: var(--accent); - color: white; + color: var(--bg-main); font-size: 0.7rem; min-width: 18px; height: 18px; @@ -319,13 +426,17 @@ body { to { transform: rotate(360deg); } } -/* Sidebar Footer */ -.sidebar-footer { - padding: 14px 20px; - border-top: 1px solid var(--border-color); - background: rgba(10, 15, 26, 0.4); +/* Desktop aside */ +#desktop-aside { + height: 100%; + background-color: black; + border-right: 1px solid var(--border-color); + display: flex; + flex-direction: column; + padding: .2em; } +/* Sidebar Footer */ .api-status-badge { display: flex; align-items: center; @@ -339,14 +450,14 @@ body { height: 8px; background-color: var(--online-color); border-radius: 50%; - box-shadow: 0 0 0 0 rgba(16, 185, 129, 0.7); + box-shadow: 0 0 0 0 rgba(255, 255, 255, 0.7); animation: pulse 1.8s infinite; } @keyframes pulse { 0% { transform: scale(0.95); - box-shadow: 0 0 0 0 rgba(16, 185, 129, 0.7); + box-shadow: 0 0 0 0 rgba(255, 255, 255, 0.7); } 70% { transform: scale(1); @@ -385,15 +496,15 @@ body { .empty-state-icon { width: 80px; height: 80px; - border-radius: 24px; - background: rgba(255, 255, 255, 0.03); - border: 1px solid var(--border-color); + background: var(--bg-secondary); + /* border: 1px solid var(--border-color); */ display: flex; align-items: center; justify-content: center; margin: 0 auto 24px auto; color: var(--accent); font-size: 2rem; + align-content: center; } .empty-state-content h2 { @@ -414,15 +525,48 @@ body { display: flex; flex-direction: column; height: 100%; + position: relative; + overflow: hidden; + z-index: 0; +} + +.active-chat-container::before { + content: ""; + position: absolute; + inset: 0; + background-image: var(--background-image); + background-size: cover; + background-position: center; + background-repeat: no-repeat; + opacity: var(--background-opacity); + pointer-events: none; + z-index: 0; +} + +.active-chat-container > * { + position: relative; + z-index: 1; } .chat-header { - padding: 16px 24px; - border-bottom: 1px solid var(--border-color); + padding: .6em 1em; display: flex; - justify-content: space-between; - align-items: center; - background: rgba(15, 23, 42, 0.3); + position: relative; +} + +.chat-header::before { + content: ""; + position: absolute; + inset: 0; + pointer-events: none; + z-index: -1; + + background: linear-gradient( + to bottom, + rgba(0, 0, 0, 0.75), + rgba(0, 0, 0, 0.35), + transparent + ); } .active-contact-info { @@ -435,12 +579,12 @@ body { width: 42px; height: 42px; border-radius: 12px; + display: none; } .active-contact-info h3 { font-size: 1rem; - font-weight: 600; - margin-bottom: 2px; + font-weight: bold; } .contact-status { @@ -461,20 +605,35 @@ body { .messages-container { flex: 1; overflow-y: auto; - padding: 24px; + padding: 1rem; + padding-bottom: .6rem; display: flex; flex-direction: column; - gap: 16px; + user-select: text; background-image: - radial-gradient(circle at 10% 20%, rgba(99, 102, 241, 0.03) 0%, transparent 40%), - radial-gradient(circle at 90% 80%, rgba(168, 85, 247, 0.03) 0%, transparent 40%); + radial-gradient(circle at 10% 20%, rgba(99, 102, 241, 0.03) 0%, transparent 40%), + radial-gradient(circle at 90% 80%, rgba(168, 85, 247, 0.03) 0%, transparent 40%); +} + +.load-more-btn { + margin: auto; + background-color: rgba(255, 255, 255, 0.1); + padding: .4em; + cursor: pointer; + box-shadow: var(--high-box-shadow); +} + +.load-more-btn:hover { + background-color: var(--text-primary); + color: var(--bg-main); } .message-group { + margin-top: .8em; display: flex; flex-direction: column; max-width: 65%; - gap: 4px; + transition: .1s; } .message-group.incoming { @@ -485,17 +644,28 @@ body { align-self: flex-end; } +.message-group.same-sender { + margin-top: .4em; +} + .message-sender { font-size: 0.75rem; font-weight: 600; - color: var(--text-muted); - margin-left: 12px; - margin-bottom: 2px; + color: var(--text-primary); + width: 100%; + display: flex; +} + +.message-indicator { + width: 0; + height: 0; + margin: 0px 10px; } .message-bubble { - padding: 12px 16px; - border-radius: 18px; + display: flex; + flex-direction: column; + padding: 8px 10px; font-size: 0.92rem; line-height: 1.5; position: relative; @@ -506,14 +676,33 @@ body { .message-group.incoming .message-bubble { background-color: var(--bubble-incoming); color: var(--text-primary); - border-top-left-radius: 4px; border: 1px solid var(--border-color); } .message-group.outgoing .message-bubble { background: var(--bubble-outgoing); color: white; - border-top-right-radius: 4px; +} + +.message-group.outgoing .message-indicator { + border-left: 10px solid transparent; + border-bottom: 10px solid var(--bubble-outgoing); + margin-left: auto; +} + +.message-group.incoming .message-indicator { + border-right: 10px solid transparent; + border-bottom: 10px solid var(--bubble-incoming); +} + +.message-content { + display: flex; + flex-direction: column; + gap: .4em; +} + +.message-content * { + user-select: text; } .message-meta { @@ -522,22 +711,56 @@ body { justify-content: flex-end; gap: 4px; font-size: 0.7rem; - color: rgba(255, 255, 255, 0.65); - margin-top: 4px; } -.message-group.incoming .message-meta { - color: var(--text-muted); +.message-image-attachement { + max-width: 100%; + max-height: 10em; } /* Chat Input Panel */ .chat-input-panel { - padding: 20px 24px; - background: var(--input-bg); - border-top: 1px solid var(--border-color); + padding: .8rem; display: flex; align-items: center; gap: 16px; + background-color: var(--bg-main); +} + +.alternate-panel { + background-color: var(--bg-secondary); + padding: .4em; + display: flex; + justify-content: center; + align-items: center; + gap: .6em; + position: absolute; + left: 0; + right: 0; + bottom: 0; + transform: translateY(0); + transition: transform .3s; + flex: 1; +} + +.alternate-panel.collapsed { + transform: translateY(100%); +} + +.alternate-panel button, .alternate-panel input { + border: medium solid var(--text-primary); + border-radius: 100%; + background-color: transparent; +} + +.alternate-panel button:hover, .alternate-panel input:hover { + border-color: var(--bg-primary); + background-color: var(--text-primary); + color: var(--bg-primary); +} + +.chat-input-panel button { + background-color: transparent; } .input-actions-left { @@ -550,30 +773,30 @@ body { display: flex; gap: 12px; align-items: center; + min-width: 0; } #message-input { flex: 1; padding: 12px 18px; - background: rgba(255, 255, 255, 0.04); - border: 1px solid var(--border-color); - border-radius: 12px; - color: var(--text-primary); + background-color: var(--text-primary); + border: medium solid var(--border-color); + color: var(--bg-main); font-size: 0.95rem; transition: all 0.2s ease; + min-width: 0; } #message-input:focus { + color: var(--text-primary); outline: none; border-color: var(--accent); background: rgba(255, 255, 255, 0.06); - box-shadow: 0 0 0 2px rgba(99, 102, 241, 0.1); } .send-btn { width: 44px; height: 44px; - border-radius: 12px; background: var(--accent-gradient); border: none; color: white; @@ -585,11 +808,6 @@ body { transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1); } -.send-btn:hover { - transform: scale(1.05) translateY(-1px); - box-shadow: 0 6px 20px rgba(99, 102, 241, 0.4); -} - .send-btn:active { transform: scale(0.98) translateY(0); } @@ -611,7 +829,7 @@ body { ::-webkit-scrollbar-thumb { background: rgba(255, 255, 255, 0.08); - border-radius: 10px; + border-radius: 0px; } ::-webkit-scrollbar-thumb:hover { @@ -623,61 +841,169 @@ body { display: none !important; } -/* Responsive design */ +/* Extra Pages */ +.extra-page { + display: none; + width: 100%; +} + +.extra-page-content { + padding: 24px; + color: var(--text-secondary); +} + +#chat-page { + display: flex; +} + +#profile-page { + flex-direction: column; + background-color: var(--bg-main); +} + +#profile-page .content { + padding: 1.4rem; + display: flex; + gap: 1em; +} + +#profile-page-user-info { + flex: 1; +} + +#profile-page h2 { + padding: 1.4rem; + font-size: 5rem; + text-wrap-mode: nowrap; + overflow: hidden; + font-weight: 200; +} + +#profile-page-picture { + width: 100%; + max-width: 10%; + height: auto; + aspect-ratio: 1/1; +} + +#profile-page-status-input { + width: 100%; + background-color: var(--bg-main); + font-size: xx-large; + border-bottom: medium solid transparent; + padding: 0; +} + +#profile-page-status-input:focus { + color: var(--text-primary); + border-bottom-color: var(--text-primary); +} + @media (max-width: 768px) { .app-container { - position: relative; + width: 100%; + height: 100%; + display: flex; + flex-direction: row; + overflow-x: auto; + overflow-y: hidden; + scroll-snap-type: x mandatory; + -webkit-overflow-scrolling: touch; + + /* Hide scrollbars */ + scrollbar-width: none; /* Firefox */ + -ms-overflow-style: none; /* IE and Edge */ + } + + .app-container::-webkit-scrollbar { + display: none; /* Chrome, Safari, Opera */ } .sidebar { width: 100%; - position: absolute; - left: 0; - top: 0; + flex: 0 0 100%; + position: relative; + left: auto; + top: auto; height: 100%; - z-index: 10; - } - - .sidebar.hidden { - transform: translateX(-100%); - display: flex !important; /* overrides standard .hidden */ + z-index: 1; + scroll-snap-align: start; + scroll-snap-stop: always; } .chat-area { width: 100%; + flex: 0 0 100%; + position: relative; + left: auto; + top: auto; + height: 100%; + z-index: 1; + scroll-snap-align: start; + scroll-snap-stop: always; + } + + .extra-page { + display: block; + width: 100%; + flex: 0 0 100%; + position: relative; + left: auto; + top: auto; + height: 100%; + z-index: 1; + scroll-snap-align: start; + scroll-snap-stop: always; + background-color: var(--bg-main); + overflow-y: auto; } .back-btn { display: flex; - margin-right: 8px; + margin-right: 12px; + } + + .message-group { + max-width: 90%; + } + + .message-image-attachement { + max-height: 20em; + } + + #desktop-aside { + display: none; + } + + #profile-page .content { + flex-direction: column; + } + + #profile-page-picture { + max-width: 50%; + margin: auto; + } + + #profile-page-user-number { + text-align: center; } } /* Modal Styling */ -.modal-overlay { - position: fixed; - top: 0; - left: 0; - width: 100vw; - height: 100vh; - background: rgba(0, 0, 0, 0.6); - backdrop-filter: blur(8px); - display: flex; - align-items: center; - justify-content: center; - z-index: 100; - transition: all 0.3s ease; -} - .modal-content { - background: rgba(30, 41, 59, 0.85); - border: 1px solid var(--border-color); - border-radius: 16px; - width: 90%; - max-width: 480px; + width: 100%; + background: var(--bg-main); padding: 24px; box-shadow: var(--shadow-lg); backdrop-filter: var(--glass-blur); + display: flex; + flex-direction: column; + height: 100%; +} + +.modal-body h3 { + font-size: xx-large; + font-weight: 100; } .modal-header { @@ -688,7 +1014,7 @@ body { } .modal-header h2 { - font-size: 1.2rem; + font-size: xx-large; font-weight: 600; } @@ -710,20 +1036,6 @@ body { font-weight: 500; } -.form-group input { - padding: 10px 12px; - border-radius: 8px; - border: 1px solid var(--border-color); - background: rgba(15, 23, 42, 0.5); - color: var(--text-primary); - font-size: 0.9rem; -} - -.form-group input:focus { - outline: none; - border-color: var(--accent); -} - .settings-warning { font-size: 0.75rem; color: var(--text-muted); @@ -734,12 +1046,11 @@ body { display: flex; justify-content: flex-end; gap: 12px; - margin-top: 24px; + margin-top: auto; } .btn { padding: 10px 18px; - border-radius: 8px; font-size: 0.9rem; font-weight: 500; cursor: pointer; @@ -752,18 +1063,13 @@ body { color: white; } -.primary-btn:hover { - transform: translateY(-1px); - box-shadow: 0 4px 12px rgba(99, 102, 241, 0.3); -} - .secondary-btn { - background: rgba(255, 255, 255, 0.05); + background: var(--bg-secondary); color: var(--text-primary); - border: 1px solid var(--border-color); } .secondary-btn:hover { - background: rgba(255, 255, 255, 0.1); + background: var(--text-primary); + color: var(--bg-main); } diff --git a/wahaService.js b/wahaService.js deleted file mode 100644 index 39394a2..0000000 --- a/wahaService.js +++ /dev/null @@ -1,77 +0,0 @@ -import axios from "axios"; - -const session = "session_01kxc62bk5fs8vh4v127k88a7j"; -const wahaBaseUrl = "http://inspiran.beetal-castor.ts.net:3100"; -const apiKey = process.env.WAHA_API_KEY; - -const client = axios.create({ - baseURL: wahaBaseUrl, - headers: { - "X-API-KEY": apiKey, - "Content-Type": "application/json" - } -}); - -export const wahaService = { - getConfigStatus() { - return { - wahaBaseUrl, - session, - hasApiKey: !!apiKey - }; - }, - - async getChats() { - const response = await client.get(`/api/${session}/chats`, { timeout: 5000 }); - - if (!Array.isArray(response.data)) { - throw new Error("Invalid chats response format from WAHA API"); - } - - return response.data.map(chat => { - let chatId = chat.id; - if (chatId && typeof chatId === "object") { - chatId = chatId._serialized || chatId.user || JSON.stringify(chatId); - } - return { - id: chatId || chat.chatId || chat.name, - name: chat.name || "Unknown Contact", - unreadCount: chat.unreadCount || 0, - lastMessage: chat.lastMessage?.body || chat.lastMessageText || "Click to open chat", - timestamp: chat.lastMessage?.timestamp || new Date() - }; - }); - }, - - async getChatMessages(chatId) { - const response = await client.get(`/api/${session}/chats/${chatId}/messages?downloadMedia=false&merge=true&limit=10`); - return response.data; - }, - - async getMyInfo(chatId) { - const response = await client.get(`/api/${session}/me`); - return response.data; - }, - - async startTyping(chatId) { - await client.post("/api/startTyping", { - chatId, - session - }, { timeout: 3000 }); - }, - - async stopTyping(chatId) { - await client.post("/api/stopTyping", { - chatId, - session - }, { timeout: 2000 }); - }, - - async sendTextMessage(chatId, text) { - const response = await client.post("/api/sendText", { - chatId, - text - }); - return response.data; - } -};