293 lines
No EOL
9.9 KiB
TypeScript
293 lines
No EOL
9.9 KiB
TypeScript
import util from "./util"
|
|
|
|
import { Message, Author } from "./message"
|
|
import { MessageThread } from "./thread"
|
|
import { AdapterState } from "./adapter"
|
|
import { BatchTimer } from "./batch-timer"
|
|
|
|
export class AdapterElement extends HTMLElement {
|
|
static observedAttributes = [ "data-latest", "data-view", "data-viewing" ]
|
|
|
|
private _latest: string = "" ;
|
|
private _view: string = "";
|
|
private _name: string = ""
|
|
private _viewing: string = "";
|
|
|
|
private _convoyBatchTimer = new BatchTimer((ids: string[])=>{
|
|
let url = `/api/adapters/${this._name}/fetch?entity_type=convoy`;
|
|
for (let id of ids) {
|
|
url += `&entity_id=${id}`;
|
|
}
|
|
util.authorizedFetch("GET", url, null)
|
|
});
|
|
|
|
// TODO: use visibility of the thread to organize into DMs and public threads
|
|
private _threads: MessageThread[] = [];
|
|
private _orphans: Message[] = [];
|
|
|
|
constructor() {
|
|
super();
|
|
}
|
|
|
|
connectedCallback() {
|
|
const name = this.getAttribute("data-name");
|
|
this._name = name ?? "";
|
|
this._view = "";
|
|
this.buildThreads();
|
|
this.setAttribute("data-view", "index");
|
|
}
|
|
|
|
attributeChangedCallback() {
|
|
// set the viewing subject if it's changed
|
|
const viewing = this.getAttribute("data-viewing");
|
|
if (this._viewing != viewing && viewing != null) {
|
|
console.log(`${this._name}.attributeChangedCallback: resetting viewing subject`);
|
|
this._viewing = viewing;
|
|
// if the viewing subject changed (not to nothing), unset the view
|
|
// this will force it to refresh
|
|
if (this._viewing) {
|
|
|
|
console.log(`${this._name}.attributeChangedCallback: forcing view update`);
|
|
this._view = "";
|
|
}
|
|
}
|
|
|
|
// initialize the view if it's changed
|
|
const view = this.getAttribute("data-view");
|
|
if (this._view != view ?? "index") {
|
|
this._view = view ?? "index";
|
|
|
|
console.log(`${this._name}.attributeChangedCallback: setting view: ${this._view}`);
|
|
switch (this._view) {
|
|
case "index":
|
|
this.setIdxView();
|
|
this.populateIdxView();
|
|
break;
|
|
case "thread":
|
|
this.setThreadView();
|
|
this.populateThreadView();
|
|
break;
|
|
case "profile":
|
|
this.setProfileView();
|
|
this.populateProfileView();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// if latest changed, check if it's a message
|
|
const latest = this.getAttribute("data-latest");
|
|
if (latest ?? "" != this._latest) {
|
|
this._latest = latest ?? "";
|
|
let datastore = AdapterState._instance.data.get(this._name);
|
|
if (!datastore) {
|
|
//util.errMsg(this._name + " has no datastore!");
|
|
return;
|
|
}
|
|
const latestMsg = datastore.messages.get(this._latest);
|
|
if (latestMsg) {
|
|
console.log('latest was a message; place it');
|
|
const rootId = this.placeMsg(this._latest);
|
|
// if rootId is null, this is an orphan and we don't need to actually do any updates yet
|
|
if (rootId) {
|
|
switch (this._view) {
|
|
case "index":
|
|
console.log(`message was placed in thread ${rootId}, update view`)
|
|
this.updateIdxView(this._latest, rootId);
|
|
break;
|
|
case "thread":
|
|
// if the the message is part of this thread, update it
|
|
case "profile":
|
|
// if the message is from this user, show it in their profile
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
const latestAuthor = datastore.profileCache.get(this._latest);
|
|
if (latestAuthor) {
|
|
switch (this._view) {
|
|
case "index":
|
|
console.log (`author was updated: ${this._latest}, update their threads`)
|
|
const threadsByThisAuthor = this._threads.filter(t=>t.root.data.author == this._latest);
|
|
for (let t of threadsByThisAuthor) {
|
|
let tse = this.querySelector(`underbbs-thread-summary[data-msg='${t.root.data.id}']`)
|
|
if (tse) {
|
|
console.log(`author has a thread in the dom, update it: ${t.root.data.id}`)
|
|
tse.setAttribute("data-author", this._latest);
|
|
}
|
|
}
|
|
case "thread":
|
|
case "profile":
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// so, try to insert it into the threads
|
|
// then, switch on view
|
|
// if index, iterate through the topics and find the one to indicate new activity,
|
|
// if thread, if any relatives are in this thread, insert message appropriately
|
|
// if profile, if latest is this profile, update it
|
|
}
|
|
|
|
}
|
|
|
|
setIdxView() {
|
|
this.innerHTML = "<ul id='dm_list'></ul><ul id='public_list'></ul>"
|
|
}
|
|
|
|
setThreadView() {
|
|
let html = `<a href="#${this._name}">← return to index</a>`;
|
|
html += "<ul id='msg_list'></ul>";
|
|
this.innerHTML = html;
|
|
}
|
|
|
|
setProfileView() {
|
|
let profile_bar = util.$("profile_bar");
|
|
if (profile_bar) {
|
|
// clear any previous data
|
|
} else {
|
|
// insert the profileSidebar into the dom
|
|
}
|
|
}
|
|
|
|
populateIdxView() {
|
|
// skip dm list for now
|
|
// public/unified list
|
|
const pl = util.$("public_list");
|
|
if (pl) {
|
|
let html = "";
|
|
for (const t of this._threads.sort((a: MessageThread, b: MessageThread) => b.latest - a.latest)) {
|
|
html +=`<li><underbbs-thread-summary data-len="${t.messageCount}" data-adapter="${t.root.data.adapter}" data-msg="${t.root.data.id}" data-created="${t.created}" data-latest="${t.latest}"></underbbs-thread-summary></li>`;
|
|
}
|
|
pl.innerHTML = html;
|
|
}
|
|
}
|
|
|
|
updateIdxView(latest: string, rootId: string) {
|
|
const existingThread = document.querySelector(`underbbs-thread-summary[data-msg='${rootId}']`);
|
|
const thread = this._threads.find(t=>t.root.data.id == rootId);
|
|
console.log(`looking for thread ${rootId}`)
|
|
console.log(`- DOM object: ${existingThread}`);
|
|
console.log(`- in memory: ${thread}`);
|
|
if (existingThread && thread) {
|
|
console.log(`updating thread: ${thread.root.data.id} // ${thread.messageCount} NEW`)
|
|
existingThread.setAttribute("data-latest", `${thread.latest}`);
|
|
existingThread.setAttribute("data-len", `${thread.messageCount}`);
|
|
existingThread.setAttribute("data-new", "true");
|
|
} else {
|
|
// unified/public list for now
|
|
const pl = util.$("public_list");
|
|
if (pl && thread) {
|
|
const li = document.createElement("li");
|
|
li.innerHTML = `<underbbs-thread-summary data-len="1" data-adapter="${thread.root.data.adapter}" data-msg="${thread.root.data.id}" data-latest="${thread.latest}" data-created="${thread.created}"></underbbs-thread-summary>`;
|
|
let nextThread: Element | null = null;
|
|
for (let i = 0; i < pl.children.length; i++) {
|
|
const c = pl.children.item(i);
|
|
const latest = c?.children.item(0)?.getAttribute("data-latest")
|
|
if (latest && parseInt(latest) < thread.latest) {
|
|
nextThread = c;
|
|
break;
|
|
}
|
|
}
|
|
if (nextThread) {
|
|
nextThread.insertAdjacentElement('beforebegin', li)
|
|
return
|
|
}
|
|
pl.append(li);
|
|
}
|
|
}
|
|
}
|
|
|
|
populateThreadView() {
|
|
}
|
|
|
|
populateProfileView() {
|
|
}
|
|
|
|
buildThreads() {
|
|
const datastore = AdapterState._instance.data.get(this._name);
|
|
if (!datastore) {
|
|
util.errMsg(this._name + " has no datastore!");
|
|
return;
|
|
}
|
|
// make multiple passes over the store until every message is either
|
|
// placed in a thread, or orphaned and waiting for its parent to be returned
|
|
do{
|
|
for (let k of datastore.messages.keys()) {
|
|
this.placeMsg(k);
|
|
}
|
|
} while (this._threads.reduce((sum: number, thread: MessageThread)=>{
|
|
return sum + thread.messageCount;
|
|
}, 0) + this._orphans.length < datastore.messages.size);
|
|
}
|
|
|
|
placeMsg(k: string): string | null {
|
|
const datastore = AdapterState._instance.data.get(this._name);
|
|
if (!datastore) {
|
|
util.errMsg(this._name + " has no datastore!");
|
|
return null;
|
|
}
|
|
const msg = datastore.messages.get(k);
|
|
if (!msg) {
|
|
util.errMsg(`message [${this._name}:${k}] doesn't exist`);
|
|
return null;
|
|
}
|
|
for (let t of this._threads) {
|
|
// avoid processing nodes again on subsequent passes
|
|
if (!msg || t.findNode(t.root, msg.id)) {
|
|
return null;
|
|
}
|
|
if (msg.replyTo) {
|
|
let x = t.addReply(msg.replyTo, msg);
|
|
if (x) {
|
|
// after adding, we try to adopt some orphans
|
|
const orphanChildren = this._orphans.filter(m=>m.replyTo == k);
|
|
for (let o of orphanChildren) {
|
|
let adopted = this.placeMsg(o.id);
|
|
if (adopted) {
|
|
this._orphans.splice(this._orphans.indexOf(o), 1);
|
|
}
|
|
}
|
|
return t.root.data.id;
|
|
}
|
|
}
|
|
}
|
|
// if we made it this far, this message doesn't go in any existing thread
|
|
|
|
// if it doesn't have a parent, we can make a new thread with it
|
|
if (!msg.replyTo) {
|
|
this._threads.push(new MessageThread(msg));
|
|
// after adding, we try to adopt some orphans
|
|
const orphanChildren = this._orphans.filter(m=>m.replyTo == k);
|
|
for (let o of orphanChildren) {
|
|
let adopted = this.placeMsg(o.id);
|
|
if (adopted) {
|
|
this._orphans.splice(this._orphans.indexOf(o), 1);
|
|
}
|
|
}
|
|
return msg.id;
|
|
}
|
|
|
|
// then, we should check if its parent is an orphan
|
|
const orphanedParent = this._orphans.find(o=>o.id == msg.replyTo);
|
|
if (orphanedParent) {
|
|
// then, try to place them both
|
|
|
|
if (this.placeMsg(orphanedParent.id)) {
|
|
this._orphans.splice(this._orphans.indexOf(orphanedParent), 1);
|
|
return this.placeMsg(k);
|
|
}
|
|
}
|
|
|
|
// otherwise we can orphan it and try to fill it in later
|
|
if (this._orphans.filter(o=>o.id == msg.id).length == 0) {
|
|
this._orphans.push(msg);
|
|
if (msg.replyTo) {
|
|
this._convoyBatchTimer.queue(k, 2000);
|
|
}
|
|
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
} |