@3sln/trove 0.0.2

package/packages/web/src/bl/social.js

@@ -0,0 +1,234 @@
+// SocialService — the client side of identity, conversations, tags, and mention
+// notifications. Reactive (the workbench `watch`es it): it holds the current
+// principal, the notification inbox (polled + refreshed on demand), and the
+// active file's sidecar (tags + threaded comments). It also owns the web-push
+// subscription flow (register the service worker, subscribe with the server's
+// VAPID key). All mutations optimistically reload the affected sidecar.
+
+import { cell } from '../runtime.js';
+
+export class SocialService {
+  constructor(platform) {
+    this.platform = platform;
+    this.api = platform.api;
+    this.state = {
+      me: null,
+      notifications: { items: [], unread: 0 },
+      inboxOpen: false,
+      pushSupported: 'serviceWorker' in navigator && 'PushManager' in window,
+      pushEnabled: false,
+      sidecar: null, // { nodeId, tags, comments, subscribers, loading, error }
+      backlinks: null, // { nodeId, items, loading, error } — what links to the open item
+      posting: false,
+      replyTo: null, // { id, author } when composing a reply
+    };
+    this.cell = cell(this.state);
+    this._pollTimer = null;
+  }
+
+  observe() {
+    return this.cell;
+  }
+  #set(patch) {
+    this.state = { ...this.state, ...patch };
+    this.cell.setValue(this.state);
+  }
+
+  async init() {
+    try {
+      const me = await this.api.me();
+      this.#set({ me: me.principal, admin: !!me.admin });
+    } catch { /* anonymous / offline */ }
+    await this.refreshNotifications();
+    // Light polling; the service worker also nudges on push.
+    this._pollTimer = setInterval(() => this.refreshNotifications(), 45_000);
+    if (this._pollTimer.unref) this._pollTimer.unref();
+    this.#detectPush();
+    window.addEventListener('focus', () => this.refreshNotifications());
+    navigator.serviceWorker?.addEventListener?.('message', (e) => {
+      if (e.data?.type === 'trove-push') this.refreshNotifications();
+    });
+  }
+
+  async refreshNotifications() {
+    try {
+      const n = await this.api.notifications();
+      this.#set({ notifications: n });
+    } catch { /* not enabled / offline */ }
+  }
+
+  toggleInbox(open) {
+    const next = open ?? !this.state.inboxOpen;
+    this.#set({ inboxOpen: next });
+    if (next && this.state.notifications.unread) this.markAllRead();
+  }
+  async markAllRead() {
+    try {
+      await this.api.markNotificationsRead();
+      this.#set({ notifications: { ...this.state.notifications, unread: 0, items: this.state.notifications.items.map((i) => ({ ...i, read: true })) } });
+    } catch { /* ignore */ }
+  }
+
+  // --- sidecar (per active file) ---------------------------------------------
+
+  async loadSidecar(nodeId) {
+    if (!nodeId) return this.#set({ sidecar: null, backlinks: null });
+    this.#set({ sidecar: { nodeId, loading: true, tags: [], comments: [], subscribers: [] } });
+    this.loadBacklinks(nodeId);
+    try {
+      const view = await this.api.sidecar(nodeId);
+      // A slower request for a previously-open item must not land on this one — the
+      // same guard loadBacklinks already had. Without it, opening A then quickly opening
+      // B let A resolve last, so `state.sidecar.nodeId` became A while B was on screen
+      // and comment()/addTag()/removeTag() all wrote to A.
+      if (this.state.sidecar?.nodeId !== nodeId) return;
+      this.#set({ sidecar: { ...view, loading: false } });
+    } catch (err) {
+      if (this.state.sidecar?.nodeId !== nodeId) return;
+      this.#set({ sidecar: { nodeId, loading: false, error: err.message, tags: [], comments: [] } });
+    }
+  }
+
+  /**
+   * What links to this item. With no folders, this is how you find out where an item
+   * "lives" — which documents gather it up — so a failure has to be visible rather
+   * than rendering as "nothing links here", which would be a claim about the drive.
+   */
+  async loadBacklinks(nodeId) {
+    if (!nodeId) return this.#set({ backlinks: null });
+    this.#set({ backlinks: { nodeId, items: [], loading: true, error: null } });
+    try {
+      const res = await this.api.backlinks(nodeId);
+      // A slower request for a previously-open item must not land on this one.
+      if (this.state.backlinks?.nodeId !== nodeId) return;
+      this.#set({ backlinks: { nodeId, items: res.items || [], loading: false, error: null } });
+    } catch (err) {
+      if (this.state.backlinks?.nodeId !== nodeId) return;
+      this.#set({ backlinks: { nodeId, items: [], loading: false, error: err.message } });
+    }
+  }
+  async #reload() {
+    if (this.state.sidecar?.nodeId) await this.loadSidecar(this.state.sidecar.nodeId);
+  }
+
+  setReplyTo(target) {
+    this.#set({ replyTo: target });
+  }
+  async comment(body) {
+    const nodeId = this.state.sidecar?.nodeId;
+    if (!nodeId || !body.trim()) return;
+    const parentId = this.state.replyTo?.id || null;
+    // Offline → queue the op; it replays (CRDT-merges) on reconnect.
+    if (this.offline && !this.offline.state.online) {
+      await this.offline.queueOp({ method: 'POST', path: `/api/items/${encodeURIComponent(nodeId)}/comments`, body: { body, parentId } });
+      this.#set({ replyTo: null });
+      this.platform.notifications.info('Offline — your comment will post when you reconnect.');
+      return;
+    }
+    this.#set({ posting: true });
+    try {
+      await this.api.addComment(nodeId, { body, parentId });
+      this.#set({ replyTo: null });
+      await this.#reload();
+    } catch (err) {
+      this.platform.notifications.error(`Couldn't post comment: ${err.message}`);
+    } finally {
+      this.#set({ posting: false });
+    }
+  }
+  async deleteComment(cid) {
+    const nodeId = this.state.sidecar?.nodeId;
+    await this.api.deleteComment(nodeId, cid).catch((e) => this.platform.notifications.error(e.message));
+    await this.#reload();
+  }
+  async react(cid, emoji) {
+    const nodeId = this.state.sidecar?.nodeId;
+    const comment = findComment(this.state.sidecar?.comments || [], cid);
+    const on = !(comment?.reactions?.[emoji] || []).includes(this.state.me?.id);
+    try {
+      await this.api.reactComment(nodeId, cid, emoji, on);
+    } catch (err) {
+      this.platform.notifications.error(`Couldn't react: ${err.message}`);
+    }
+    await this.#reload();
+  }
+  async addTag(name, value) {
+    const nodeId = this.state.sidecar?.nodeId;
+    if (!name.trim()) return;
+    if (this.offline && !this.offline.state.online) {
+      await this.offline.queueOp({ method: 'POST', path: `/api/items/${encodeURIComponent(nodeId)}/tags`, body: { name: name.trim(), value } });
+      this.platform.notifications.info('Offline — tag will sync when you reconnect.');
+      return;
+    }
+    await this.api.setTag(nodeId, name.trim(), value).catch((e) => this.platform.notifications.error(e.message));
+    await this.#reload();
+  }
+  async removeTag(name) {
+    const nodeId = this.state.sidecar?.nodeId;
+    // Offline → queue like addTag so the removal isn't silently lost.
+    if (this.offline && !this.offline.state.online) {
+      await this.offline.queueOp({ method: 'DELETE', path: `/api/items/${encodeURIComponent(nodeId)}/tags/${encodeURIComponent(name)}` });
+      this.platform.notifications.info('Offline — tag removal will sync when you reconnect.');
+      return;
+    }
+    try {
+      await this.api.removeTag(nodeId, name);
+    } catch (err) {
+      this.platform.notifications.error(`Couldn't remove tag: ${err.message}`);
+    }
+    await this.#reload();
+  }
+
+  // --- web push --------------------------------------------------------------
+
+  async #detectPush() {
+    if (!this.state.pushSupported) return;
+    try {
+      const reg = await navigator.serviceWorker.getRegistration();
+      const sub = await reg?.pushManager?.getSubscription();
+      this.#set({ pushEnabled: !!sub });
+    } catch { /* ignore */ }
+  }
+
+  async enablePush() {
+    if (!this.state.pushSupported) {
+      this.platform.notifications.warn('Push notifications are not supported in this browser.');
+      return;
+    }
+    try {
+      const { publicKey } = await this.api.vapidKey();
+      if (!publicKey) {
+        this.platform.notifications.warn('This server has no VAPID key configured for web push.');
+        return;
+      }
+      const reg = await navigator.serviceWorker.register('/sw.js');
+      await navigator.serviceWorker.ready;
+      const perm = await Notification.requestPermission();
+      if (perm !== 'granted') return this.platform.notifications.info('Notifications permission was denied.');
+      const sub = await reg.pushManager.subscribe({ userVisibleOnly: true, applicationServerKey: urlBase64ToUint8Array(publicKey) });
+      await this.api.subscribePush(sub.toJSON());
+      this.#set({ pushEnabled: true });
+      this.platform.notifications.success('Notifications enabled — you’ll be pinged when someone @mentions you.');
+    } catch (err) {
+      this.platform.notifications.error(`Couldn't enable notifications: ${err.message}`);
+    }
+  }
+}
+
+function findComment(list, cid) {
+  for (const c of list) {
+    if (c.id === cid) return c;
+    const inner = findComment(c.replies || [], cid);
+    if (inner) return inner;
+  }
+  return null;
+}
+
+function urlBase64ToUint8Array(base64) {
+  const padding = '='.repeat((4 - (base64.length % 4)) % 4);
+  const b64 = (base64 + padding).replace(/-/g, '+').replace(/_/g, '/');
+  const raw = atob(b64);
+  const out = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i++) out[i] = raw.charCodeAt(i);
+  return out;
+}

package/packages/web/src/bl/tagQuery.js

@@ -0,0 +1,44 @@
+// Parse `#tag` / `#key:op:value` filter tokens out of a launcher query and match
+// nodes against them. Grammar (each token, space-separated):
+//   #tag              → the property/tag is present
+//   #key:=v  #key:!=v #key:<v #key:<=v #key:>v #key:>=v  → compare
+//   #key:v            → equality shorthand (same as #key:=v)
+// Values may be "quoted" to include spaces. Comparisons are numeric when both
+// sides parse as numbers, otherwise case-insensitive string comparisons.
+
+import { matchTagFilters } from '@3sln/trove/core/search/tagMatch.js';
+
+const TOKEN = /#([\w.-]+)(?::(<=|>=|!=|=|<|>)?("[^"]*"|[^#\s]+)?)?/g;
+
+/** @returns {{ text: string, filters: {key,op,value,present}[] }} */
+export function parseTagQuery(query) {
+  const filters = [];
+  let text = query;
+  for (const m of query.matchAll(TOKEN)) {
+    const [, key, op, rawValue] = m;
+    const value = rawValue && rawValue.startsWith('"') ? rawValue.slice(1, -1) : rawValue;
+    filters.push(value == null || value === ''
+      ? { key, present: true }
+      : { key, op: op || '=', value, present: false });
+    text = text.replace(m[0], ' ');
+  }
+  return { text: text.replace(/\s+/g, ' ').trim(), filters };
+}
+
+/**
+ * True if `node` satisfies ALL filters (AND).
+ *
+ * Delegates to core rather than re-implementing. This file had its own copy, and the
+ * two drifted on the ordering operators — the client lowercased both operands, the
+ * server did not — so `#author:>Bob` against `author: "alice"` answered differently
+ * online and offline. Same query, same drive, different files.
+ */
+export function matchesTagFilters(node, filters) {
+  if (!filters || !filters.length) return true;
+  return matchTagFilters(node, filters);
+}
+
+/** Short human label for a filter (for the results heading). */
+export function filterLabel(f) {
+  return f.present ? `#${f.key}` : `#${f.key}:${f.op}${f.value}`;
+}

package/packages/web/src/main.js

@@ -0,0 +1,10 @@
+// The open-source build's entry point: a workbench with nothing added to it.
+//
+// Everything that used to live here is `createWorkbench` (./workbench.js), which takes
+// the openers and views a build wants to ship. A hosted or bespoke build imports that
+// instead of this file and passes its own — no fork, and the same registry the plugins
+// use.
+
+import { createWorkbench } from './workbench.js';
+
+createWorkbench();