allaboard 0.0.0-stage → 0.4.0

package/dist/chat/slack/reply/places.js

@@ -0,0 +1,262 @@
+/**
+ * Where the messages of one thread sit, as far as the daemon saw them: the owner's, and the last
+ * message of each reply. Kept in memory only (a restart forgets it), and decided by `isLast`,
+ * `isOvertaken` and `tails` of the core. The session's footer is not placed here: the session
+ * names the reply it goes under. A reply the places let go of leaves its position behind
+ * in `floor`, so that the answers do not change when it goes, and keeps showing what it showed.
+ */
+import { isLast, isOvertaken, Mutex, tails, } from "../../../core/port.js";
+/**
+ * A Slack `ts` as an integer of microseconds: exact below 2^53, ordered as the thread is. Null
+ * for text that is no `ts`, which no position is made of.
+ */
+export function positionOf(ts) {
+    if (!/^\d+(\.\d+)?$/.test(ts))
+        return null;
+    const [seconds = "0", fraction = ""] = ts.split(".");
+    const position = Number(seconds) * 1_000_000 + Number(fraction.padEnd(6, "0").slice(0, 6));
+    return Number.isSafeInteger(position) ? position : null;
+}
+export class ThreadPlaces {
+    /**
+     * Held by whoever creates a message of a reply in this thread (a stream's start, a
+     * continuation, an ending, a closing message), and by the end's decision whether to create one:
+     * two replies cannot each decide on the other's absence. Taken after a sink's own lock, and
+     * never while waiting for one.
+     */
+    lock = new Mutex();
+    replies = new Set();
+    /** The replies whose end has landed. */
+    done = new Set();
+    /** The replies whose opening thread object closed. */
+    shut = new Set();
+    /** What still runs in the thread, drawn under the reply `tails` names. */
+    list = null;
+    /** The reply that holds the list now: it is not let go of while it does. */
+    holder = null;
+    /** The replies that held the list, for a change of it that only debounced. */
+    listed = new Set();
+    /** The replies about to create their first message: below every other from then on. */
+    opening = new Set();
+    marks = [];
+    /** The highest position of a reply let go of: it still sits in the thread. */
+    floor = null;
+    /** The highest position of a message of the owner's or of one the app posted outside a reply. */
+    latest = null;
+    onEmpty;
+    /** `onEmpty` is told when the last registered reply is let go of. */
+    constructor(onEmpty = () => { }) {
+        this.onEmpty = onEmpty;
+    }
+    /** A reply exists, with a message or without. */
+    join(reply) {
+        this.replies.add(reply);
+    }
+    /** Whether the reply is registered and not let go of. */
+    holds(reply) {
+        return this.replies.has(reply);
+    }
+    /** Whether any reply is registered. */
+    get held() {
+        return this.replies.size > 0;
+    }
+    /** The owner wrote a message of this thread at `ts`. */
+    ownerPosted(ts) {
+        const at = positionOf(ts);
+        if (at === null)
+            return;
+        this.latest = Math.max(this.latest ?? at, at);
+        this.marks.push(at);
+        this.place();
+        this.release();
+        this.prune();
+    }
+    /**
+     * The app posted a message of its own in the thread, outside its replies (a notice, a request).
+     * It changes no reply's place: it only counts in `newestAt`.
+     */
+    posted(ts) {
+        const at = positionOf(ts);
+        if (at !== null)
+            this.latest = Math.max(this.latest ?? at, at);
+    }
+    /** The position of the newest message of the thread the places know of; null when none. */
+    get newestAt() {
+        let newest = this.latest ?? this.floor;
+        if (this.floor !== null && newest !== null)
+            newest = Math.max(newest, this.floor);
+        for (const reply of this.replies) {
+            if (reply.lastAt !== null)
+                newest = Math.max(newest ?? reply.lastAt, reply.lastAt);
+        }
+        return newest;
+    }
+    /** A reply got its first message, or its last message moved. */
+    moved() {
+        this.prune();
+        this.place();
+    }
+    /**
+     * The reply's end has landed: it is let go of once an owner message sits below it.
+     */
+    ended(reply) {
+        if (!this.replies.has(reply))
+            return;
+        this.done.add(reply);
+        this.place();
+        this.release();
+    }
+    /**
+     * `reply` is about to create its first message, below every other: the list leaves the reply
+     * that shows it, and that reply's edit is written before the message is created. Created first,
+     * the message showed under the list for as long as the edit waited (seen on Slack desktop,
+     * 2026-10-15). Returns the call that ends the wait for the message, created or not. Not to be
+     * called with the places' lock held: the holder's write may need it.
+     */
+    async opens(reply) {
+        this.opening.add(reply);
+        const before = this.holder;
+        this.place();
+        if (before !== null && before !== this.holder)
+            await before.unlist().catch(() => false);
+        return () => {
+            if (this.opening.delete(reply))
+                this.place();
+        };
+    }
+    /** What still runs in the thread changed; null for nothing. The holder is written at once. */
+    showRunning(list) {
+        this.list = list;
+        this.place();
+    }
+    /**
+     * The reply no longer shows the list and is not to: the close has nothing to settle on it. The
+     * holder stays, since the list may be handed to it again.
+     */
+    unlisted(reply) {
+        if (reply !== this.holder)
+            this.listed.delete(reply);
+    }
+    /**
+     * A shutdown's last chance for the changes of the list that only debounced, on every reply that
+     * held it, let go of or not, since no session settles a reply whose end landed.
+     */
+    async settleListed() {
+        const replies = [...this.listed];
+        this.listed.clear();
+        for (const reply of replies)
+            await reply.settle().catch(() => { });
+    }
+    /**
+     * Work out every reply's tail with `tails` of the core and hand each its own. Sync: a reply
+     * whose tail did not change does nothing. Called whenever a reply's position or its resting
+     * changes. A reply that stops holding the list may be let go of from then on.
+     */
+    place() {
+        const result = this.tailsOf();
+        let holder = null;
+        for (const reply of [...this.replies]) {
+            const list = result.get(reply)?.running ? this.list : null;
+            if (list !== null) {
+                holder = reply;
+                this.listed.add(reply);
+            }
+            reply.assign(list);
+        }
+        const previous = this.holder;
+        this.holder = holder;
+        if (previous !== null && previous !== holder)
+            this.release();
+    }
+    /** The tails of the registered replies that have a message. */
+    tailsOf() {
+        const entries = [];
+        for (const reply of this.replies) {
+            if (reply.lastAt !== null) {
+                entries.push({ key: reply, at: reply.lastAt, resting: reply.resting });
+            }
+            else if (this.opening.has(reply)) {
+                entries.push({ key: reply, at: Number.POSITIVE_INFINITY, resting: false });
+            }
+        }
+        return tails(entries);
+    }
+    /** The thread object that opened the reply closed: the reply is let go of, its end landed or not. */
+    closed(reply) {
+        if (!this.replies.has(reply))
+            return;
+        this.shut.add(reply);
+        this.release();
+    }
+    /** Whether nothing of the owner's and no other reply sits below the reply. */
+    last(reply) {
+        if (!this.replies.has(reply) || reply.lastAt === null)
+            return false;
+        return isLast(reply.lastAt, this.others(reply), this.marks);
+    }
+    /** Whether another reply has a message below the reply; a reply let go of keeps its answer. */
+    overtaken(reply) {
+        if (reply.lastAt === null)
+            return false;
+        return isOvertaken(reply.lastAt, this.others(reply));
+    }
+    others(reply) {
+        const at = this.floor === null ? [] : [this.floor];
+        for (const other of this.replies) {
+            if (other !== reply && other.lastAt !== null)
+                at.push(other.lastAt);
+        }
+        return at;
+    }
+    /**
+     * Lets go of the replies a closed thread or an owner message seals (`sealed`). The holder of the
+     * list stays while it holds it, unless its thread closed.
+     */
+    release() {
+        const top = this.marks.length === 0 ? null : Math.max(...this.marks);
+        let gone = false;
+        for (const reply of [...this.replies]) {
+            // A closed thread lets go of its replies whether or not their end landed: the session is
+            // gone, and nothing else would drop a reply whose end never lands.
+            if (!this.shut.has(reply) && !this.done.has(reply))
+                continue;
+            // The reply that holds the list stays while it does: the list could never be taken off a
+            // reply that is gone. A closed thread lets go of it all the same.
+            if (reply === this.holder && !this.shut.has(reply))
+                continue;
+            if (!this.sealed(reply, top))
+                continue;
+            const at = reply.lastAt;
+            if (at !== null)
+                this.floor = Math.max(this.floor ?? at, at);
+            this.done.delete(reply);
+            this.shut.delete(reply);
+            this.replies.delete(reply);
+            if (this.holder === reply)
+                this.holder = null;
+            gone = true;
+        }
+        if (gone && this.replies.size === 0)
+            this.onEmpty();
+    }
+    /**
+     * Whether a reply is let go of: its thread closed, or an owner message sits below it. The
+     * holder of the list counts as still to end while it holds it (`release`). A reply with no
+     * message yet is let go of with its thread alone.
+     */
+    sealed(reply, top) {
+        const at = reply.lastAt;
+        if (this.shut.has(reply) || at === null)
+            return true;
+        return top !== null && top > at;
+    }
+    /** Keeps the marks not below the lowest placed reply, and always the highest. */
+    prune() {
+        if (this.marks.length === 0)
+            return;
+        const top = Math.max(...this.marks);
+        const placed = [...this.replies].flatMap((reply) => reply.lastAt === null ? [] : [reply.lastAt]);
+        const lowest = Math.min(...placed);
+        this.marks = this.marks.filter((mark) => mark === top || mark >= lowest);
+    }
+}