@hanzo/rooms 0.1.35 → 0.1.37

package/dist/pending.js

@@ -0,0 +1,181 @@
+// Changes asked of the conversation store that every list already shows.
+//
+// A pin, a rename, an archive or a delete shows at once: each list draws the
+// changes held here over what it last read (`view`). No React, so a spec reads
+// it as it is.
+//
+// ONE CONVERSATION'S CHANGES GO TO THE STORE IN ORDER. Each waits for the one
+// before it to be answered, so two toggles are never answered out of order and
+// the last one asked is the one the store keeps. A change is a PATCH of the
+// fields it names, laid over the row; a refusal takes that one change back and
+// leaves the others standing, so a refused rename does not unpin a pin still
+// in flight.
+//
+// A SETTLED CHANGE IS KEPT UNTIL EVERY LIST HAS READ AFTER IT. Dropping it the
+// moment the store answers would draw the list's older read, the row back where
+// it was, until the list read again. So every read and every answer takes a
+// moment from one clock (`tick`): a list read before a change settled still
+// shows the change, one read after shows its own read, and once every list on
+// the page has read after it the change is folded away (`sweep`).
+let clock = 0;
+/** The next moment. A read takes one as it is asked for, an answer as it lands. */
+export const tick = () => ++clock;
+const entries = new Map();
+const readers = new Set();
+const listeners = new Set();
+let version = 0;
+let owner = null;
+const publish = () => {
+    version++;
+    for (const listener of listeners)
+        listener();
+};
+/** For `useSyncExternalStore`: told whenever a change is made, settled, taken back or dropped. */
+export function subscribe(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+/** For `useSyncExternalStore`: a number that moves whenever the changes do. */
+export const snapshot = () => version;
+/**
+ * Whose conversations these are: the client the lists read through. Another
+ * client is another reader or organization, and nothing asked under the last
+ * one is drawn over its rows.
+ */
+export function bind(next) {
+    if (owner !== null && owner !== next && entries.size) {
+        entries.clear();
+        publish();
+    }
+    owner = next;
+}
+/** A list joins the page; the returned function is its leaving. */
+export function enlist(reader) {
+    readers.add(reader);
+    return () => {
+        readers.delete(reader);
+        sweep();
+    };
+}
+/** Every list on the page reads the store again. */
+export function reread() {
+    for (const reader of readers)
+        reader.reload();
+}
+/** Folds each settled change every list on the page has read after into the thread it was laid over. */
+export function sweep() {
+    let moved = false;
+    for (const [id, entry] of entries) {
+        while (entry.layers.length) {
+            const layer = entry.layers[0];
+            if (!layer.settled)
+                break;
+            let read = true;
+            for (const reader of readers)
+                if (reader.at <= layer.settled)
+                    read = false;
+            if (!read)
+                break;
+            entry.layers.shift();
+            moved = true;
+            if (!layer.patch) {
+                entry.layers.length = 0;
+                break;
+            }
+            entry.seed = { ...entry.seed, ...layer.patch };
+        }
+        if (!entry.layers.length)
+            entries.delete(id);
+    }
+    if (moved)
+        publish();
+}
+/** Pinned first, then most recently spoken in: the store's own order. */
+const first = (a, b) => Number(Boolean(b.pinned)) - Number(Boolean(a.pinned)) || (b.updatedAt ?? '').localeCompare(a.updatedAt ?? '');
+/** One conversation added to a list in the store's order. */
+const place = (threads, t) => {
+    const i = threads.findIndex((one) => first(t, one) < 0);
+    return i < 0 ? [...threads, t] : [...threads.slice(0, i), t, ...threads.slice(i)];
+};
+/** A thread with changes laid over it in order; null once one of them deleted it. */
+const lay = (t, layers) => {
+    let out = t;
+    for (const layer of layers) {
+        if (!layer.patch)
+            return null;
+        out = { ...out, ...layer.patch };
+    }
+    return out;
+};
+/**
+ * A list as it reads with every change it has not read yet: `threads` read at
+ * `at`, from the archived shelf or the active one. A deleted conversation
+ * leaves; one archived or brought back leaves the shelf it is no longer on and
+ * joins the other; any other change shows in place.
+ */
+export function view(threads, at, archived) {
+    let out = threads;
+    for (const [id, entry] of entries) {
+        const unread = entry.layers.filter((layer) => !layer.settled || at < layer.settled);
+        if (!unread.length)
+            continue;
+        const i = out.findIndex((t) => t.id === id);
+        // A row this list read carries every change it read after; one it lacks is the thread before them all.
+        const want = i >= 0 ? lay(out[i], unread) : lay(entry.seed, entry.layers);
+        if (!want || Boolean(want.archived) !== archived) {
+            if (i >= 0)
+                out = out.filter((t) => t.id !== id);
+        }
+        else {
+            out = i >= 0 ? out.map((t) => (t.id === id ? want : t)) : place(out, want);
+        }
+    }
+    return out;
+}
+/**
+ * Asks the store for one change to `t`, shown at once: `patch` the fields it
+ * sets, or null for a delete, and `send` the request, made once every earlier
+ * change to the same conversation has been answered. What the store answers
+ * for those fields is what shows. On a refusal this change alone is taken back
+ * and the refusal thrown.
+ */
+export function attempt(t, patch, send) {
+    let entry = entries.get(t.id);
+    if (!entry) {
+        entry = { seed: t, layers: [], queue: Promise.resolve() };
+        entries.set(t.id, entry);
+    }
+    const held = entry;
+    const mine = { patch: patch ? { ...patch } : null, settled: 0 };
+    held.layers.push(mine);
+    publish();
+    const run = held.queue.then(async () => {
+        try {
+            const answer = await send();
+            if (answer && mine.patch) {
+                const said = answer;
+                for (const key of Object.keys(mine.patch))
+                    if (said[key] !== undefined)
+                        Object.assign(mine.patch, { [key]: said[key] });
+            }
+            mine.settled = tick();
+            publish();
+        }
+        catch (e) {
+            const i = held.layers.indexOf(mine);
+            if (i >= 0) {
+                held.layers.splice(i, 1);
+                if (!held.layers.length && entries.get(t.id) === held)
+                    entries.delete(t.id);
+                publish();
+            }
+            throw e;
+        }
+        reread();
+        sweep();
+    });
+    held.queue = run.catch(() => { });
+    return run;
+}

package/dist/recent.d.ts

@@ -9,10 +9,12 @@ export interface Recent {
     began: string;
     status?: string;
     project?: string;
+    /** A conversation its person pinned: listed first, under Pinned. */
+    pinned?: boolean;
 }
-export type Status = 'all' | 'running' | 'paused' | 'done' | 'error' | 'stopped';
+export type Status = 'all' | 'running' | 'paused' | 'done' | 'error' | 'stopped' | 'archived';
 export type Since = 'any' | 'day' | 'week' | 'month';
-export type Group = 'date' | 'state' | 'project' | 'starred' | 'none';
+export type Group = 'date' | 'state' | 'project' | 'none';
 export type Sort = 'activity' | 'created' | 'title';
 /** How the list is narrowed, grouped and sorted. */
 export interface View {
@@ -35,11 +37,13 @@ export declare const MENUS: Record<Mode, {
 }>;
 /** A kept view as this mode may hold it: anything a menu does not offer reads as the plain view's. */
 export declare function viewOf(mode: Mode, kept: unknown): View;
-/** Chat's conversations as rows. */
+/** Chat's conversations as rows: an archived one's status says so. */
 export declare function chats(threads: {
     id: string;
     title?: string;
     updatedAt?: string;
+    pinned?: boolean;
+    archived?: boolean;
 }[]): Recent[];
 /** Dev's runs as rows. */
 export declare function runs(sessions: {
@@ -53,13 +57,16 @@ export declare function runs(sessions: {
 }[]): Recent[];
 /**
  * The list as drawn: the rows the view and the words admit, sorted, and cut into
- * headed groups in the order they read. A view grouped by None is one group with
+ * headed groups in the order they read. Pinned rows come first, under Pinned,
+ * whatever the grouping; a view grouped by None holds the rest in one group with
  * no heading.
  */
-export declare function arrange(rows: Recent[], view: View, words: string, starred: Set<string>, now?: Date): {
+export declare function arrange(rows: Recent[], view: View, words: string, now?: Date): {
     title: string;
     rows: Recent[];
 }[];
+/** The heading pinned rows read under, first in every view. */
+export declare const PINNED = "Pinned";
 /**
  * How long ago a row was last active, as a list reads it at a glance: `now`,
  * `12m`, `3h`, `2d`, `5w`, `4mo`, `2y`. '' for an instant that is not one.

package/dist/recent.js

@@ -17,11 +17,14 @@ export const SINCE = [
 ];
 /** What each mode's menu offers, section by section, as Claude's Recents menu does. */
 export const MENUS = {
+    // A chat's status is whether it is archived: the store lists the two apart.
     chat: {
-        status: [],
+        status: [
+            { id: 'all', label: 'Active' },
+            { id: 'archived', label: 'Archived' },
+        ],
         group: [
             { id: 'date', label: 'Date' },
-            { id: 'starred', label: 'Starred' },
             { id: 'none', label: 'None' },
         ],
         sort: [
@@ -56,9 +59,17 @@ export function viewOf(mode, kept) {
         sort: pick(k.sort, m.sort, PLAIN.sort),
     };
 }
-/** Chat's conversations as rows. */
+/** Chat's conversations as rows: an archived one's status says so. */
 export function chats(threads) {
-    return threads.map((t) => ({ kind: 'chat', id: t.id, title: t.title || 'Untitled', at: t.updatedAt ?? '', began: t.updatedAt ?? '' }));
+    return threads.map((t) => ({
+        kind: 'chat',
+        id: t.id,
+        title: t.title || 'Untitled',
+        at: t.updatedAt ?? '',
+        began: t.updatedAt ?? '',
+        ...(t.archived ? { status: 'archived' } : {}),
+        ...(t.pinned ? { pinned: true } : {}),
+    }));
 }
 /** Dev's runs as rows. */
 export function runs(sessions) {
@@ -96,10 +107,11 @@ function day(at, now) {
 const newest = (a, b) => (a < b ? 1 : a > b ? -1 : 0);
 /**
  * The list as drawn: the rows the view and the words admit, sorted, and cut into
- * headed groups in the order they read. A view grouped by None is one group with
+ * headed groups in the order they read. Pinned rows come first, under Pinned,
+ * whatever the grouping; a view grouped by None holds the rest in one group with
  * no heading.
  */
-export function arrange(rows, view, words, starred, now = new Date()) {
+export function arrange(rows, view, words, now = new Date()) {
     const w = words.trim().toLowerCase();
     const kept = rows.filter((r) => (!w || r.title.toLowerCase().includes(w)) &&
         (view.status === 'all' || r.status === view.status) &&
@@ -113,14 +125,14 @@ export function arrange(rows, view, words, starred, now = new Date()) {
                 return STATE[r.status ?? ''] ?? 'Other';
             case 'project':
                 return r.project || 'No project';
-            case 'starred':
-                return starred.has(r.id) ? 'Starred' : 'Others';
             default:
                 return '';
         }
     };
     const groups = [];
     for (const r of kept) {
+        if (r.pinned)
+            continue;
         const title = headOf(r);
         const g = groups.find((one) => one.title === title);
         if (g)
@@ -128,12 +140,13 @@ export function arrange(rows, view, words, starred, now = new Date()) {
         else
             groups.push({ title, rows: [r] });
     }
-    if (view.group === 'starred')
-        groups.sort((a, b) => (a.title === 'Starred' ? -1 : b.title === 'Starred' ? 1 : 0));
     if (view.group === 'date')
         groups.sort((a, b) => DAYS.indexOf(a.title) - DAYS.indexOf(b.title));
-    return groups;
+    const pinned = kept.filter((r) => r.pinned);
+    return pinned.length ? [{ title: PINNED, rows: pinned }, ...groups] : groups;
 }
+/** The heading pinned rows read under, first in every view. */
+export const PINNED = 'Pinned';
 /**
  * How long ago a row was last active, as a list reads it at a glance: `now`,
  * `12m`, `3h`, `2d`, `5w`, `4mo`, `2y`. '' for an instant that is not one.

package/dist/stars.d.ts

@@ -14,3 +14,11 @@ export declare const titleOf: (name: string, direct?: boolean) => string;
  * between them through the four components that separate them.
  */
 export declare function useStarred(kind?: string): [Set<string>, (id: string) => void];
+/**
+ * The conversations starred in this browser before a pin was the server's
+ * (@hanzo/rooms 0.1.36 stopped reading the set), made pins once. Each is asked
+ * for as a pin through `pin`; once the store has taken any of them the stars
+ * are forgotten, and a store that takes none — one without the route yet —
+ * leaves them for a later visit. Answers whether they were carried.
+ */
+export declare function carry(pin: (id: string) => Promise<unknown>): Promise<boolean>;

package/dist/stars.js

@@ -73,3 +73,35 @@ export function useStarred(kind = 'rooms') {
     }, [kind]);
     return [starred, toggle];
 }
+/**
+ * The conversations starred in this browser before a pin was the server's
+ * (@hanzo/rooms 0.1.36 stopped reading the set), made pins once. Each is asked
+ * for as a pin through `pin`; once the store has taken any of them the stars
+ * are forgotten, and a store that takes none — one without the route yet —
+ * leaves them for a later visit. Answers whether they were carried.
+ */
+export async function carry(pin) {
+    const key = keyOf('threads');
+    let ids;
+    try {
+        ids = JSON.parse(localStorage.getItem(key) || '[]');
+    }
+    catch {
+        return false;
+    }
+    if (!Array.isArray(ids))
+        return false;
+    const named = ids.filter((id) => typeof id === 'string' && id !== '');
+    if (!named.length)
+        return false;
+    const said = await Promise.allSettled(named.map((id) => pin(id)));
+    if (!said.some((one) => one.status === 'fulfilled'))
+        return false;
+    try {
+        localStorage.removeItem(key);
+    }
+    catch {
+        // A browser that refuses storage asks again next visit; a pin asked twice is still one pin.
+    }
+    return true;
+}

package/dist/thread.d.ts

@@ -0,0 +1,57 @@
+import { type ReactElement, type ReactNode } from 'react';
+import type { Thread } from '@hanzo/ai';
+export interface ThreadList {
+    threads: Thread[];
+    loading: boolean;
+    error: Error | null;
+    reload: () => void;
+}
+/**
+ * The member's conversations: pinned first, then most recently spoken in, the
+ * archived ones left out — or, with `archived`, those alone — with every change
+ * in flight drawn over them. It reads again whenever a conversation changes
+ * here, and once for `seek` when it does not hold it: a conversation it has not
+ * seen is one just begun.
+ */
+export declare function useThreadList(archived?: boolean, seek?: string | null): ThreadList;
+/** What a conversation can be asked to do. Each shows at once; a refusal takes it back and says so in a toast. */
+export declare function useThreadActions(): {
+    pin: (t: Thread) => Promise<boolean>;
+    archive: (t: Thread) => Promise<boolean>;
+    rename: (t: Thread, title: string) => Promise<boolean>;
+    remove: (t: Thread) => Promise<boolean>;
+};
+/** A conversation's own address, whole: the app at `/?chat=<id>` (lib/host `talk`), wherever the rooms are drawn. */
+export declare const href: (id: string) => string;
+/**
+ * A list of conversations with their menu: a right-click on a row or a
+ * long-press opens it at the point, a row's ⋯ hangs it from itself. Its one
+ * child holds the rows (`ThreadRow`). `threads` are the list's conversations by
+ * id, `active` the one the pane holds (what the keys act on with no menu open),
+ * and `onGone` runs after that one is deleted — the room moves to a new chat —
+ * defaulting to emptying the room.
+ */
+export declare function ConversationMenu({ threads, active, onGone, children, }: {
+    threads: Map<string, Thread>;
+    active?: string | null;
+    onGone?: () => void;
+    children: ReactElement;
+}): import("react").JSX.Element;
+/**
+ * One conversation's row, inside a `ConversationMenu`: its menu opens by a
+ * right-click anywhere on it, a long-press, or its ⋯; a middle-click or a
+ * ⌘/Ctrl-click opens it in a new tab.
+ *
+ * The ⋯ stands where `aside` (the row's age) stands, and takes its place while
+ * the row is hovered, focused, open in the pane or has its menu open, and
+ * always on a touch screen, which has no hover to find it by; the rest of the
+ * time the age reads there.
+ */
+export declare function ThreadRow({ t, active, aside, listed, children, }: {
+    t: Thread;
+    active?: boolean;
+    aside?: ReactNode;
+    /** A row of a list (`role="listitem"`); false where it stands among other rows. */
+    listed?: boolean;
+    children: ReactElement;
+}): import("react").JSX.Element;