@abraca/nuxt 0.1.0

package/dist/runtime/composables/useAwarenessPeers.d.ts

@@ -0,0 +1,34 @@
+import type { MaybeRef } from 'vue';
+import type { AwarenessPeer } from '../types.js';
+/**
+ * Reactive awareness peer list with idle detection and doc-scoped filtering.
+ *
+ * Built on top of useAwarenessOf() — provides a typed, self-excluded list of
+ * connected peers, plus helpers to filter by document and detect idle state.
+ *
+ * Usage:
+ *   const { peers, peersInDoc, isIdle } = useAwarenessPeers()
+ *   const here = peersInDoc(docId)  // Computed<AwarenessPeer[]>
+ */
+export declare function useAwarenessPeers(): {
+    peers: import("vue").ComputedRef<AwarenessPeer[]>;
+    currentUser: import("vue").Ref<{
+        [x: string]: any;
+        clientId: number;
+        user?: {
+            name?: string | undefined;
+            color?: string | undefined;
+            avatar?: string | undefined;
+        } | undefined;
+    } | null, import("./useYDoc.js").AwarenessUser | {
+        [x: string]: any;
+        clientId: number;
+        user?: {
+            name?: string | undefined;
+            color?: string | undefined;
+            avatar?: string | undefined;
+        } | undefined;
+    } | null>;
+    isIdle: (clientId: number, thresholdMs?: number) => boolean;
+    peersInDoc: (docId: MaybeRef<string>) => import("vue").ComputedRef<AwarenessPeer[]>;
+};

package/dist/runtime/composables/useAwarenessPeers.js

@@ -0,0 +1,33 @@
+import { shallowRef, computed, watch, isRef } from "vue";
+import { useAwarenessOf } from "./useYDoc.js";
+export function useAwarenessPeers() {
+  const { provider } = useAbracadabra();
+  const providerRef = shallowRef(provider.value);
+  watch(provider, (p) => {
+    providerRef.value = p;
+  }, { immediate: true });
+  const { states, currentUser } = useAwarenessOf(providerRef);
+  function isIdle(clientId, thresholdMs = 45e3) {
+    const meta = providerRef.value?.awareness?.meta?.get(clientId);
+    if (!meta) return false;
+    return Date.now() - meta.lastUpdated > thresholdMs;
+  }
+  const peers = computed(
+    () => states.value.filter((s) => s.clientId !== currentUser.value?.clientId).map((s) => ({
+      ...s,
+      idle: isIdle(s.clientId)
+    }))
+  );
+  function peersInDoc(docId) {
+    return computed(() => {
+      const id = isRef(docId) ? docId.value : docId;
+      return peers.value.filter((p) => p.docId === id);
+    });
+  }
+  return {
+    peers,
+    currentUser,
+    isIdle,
+    peersInDoc
+  };
+}

package/dist/runtime/composables/useBackgroundSync.d.ts

@@ -0,0 +1,37 @@
+/**
+ * useBackgroundSync
+ *
+ * Wraps BackgroundSyncManager from @abraca/dabra.
+ * Initialized by the main plugin after root provider syncs.
+ *
+ * Usage:
+ *   const { syncStates, isSyncing, progress, syncNow } = useBackgroundSync()
+ */
+interface DocSyncState {
+    status: 'pending' | 'syncing' | 'synced' | 'error' | 'skipped';
+    lastSynced?: number;
+    error?: string;
+}
+export declare function _initBackgroundSync(manager: any, intervalMs?: number): void;
+export declare function _destroyBackgroundSync(): void;
+declare function syncNow(): Promise<void>;
+declare function syncDoc(docId: string): Promise<void>;
+export declare function useBackgroundSync(): {
+    syncStates: import("vue").Ref<Map<string, {
+        status: "pending" | "syncing" | "synced" | "error" | "skipped";
+        lastSynced?: number | undefined;
+        error?: string | undefined;
+    }> & Omit<Map<string, DocSyncState>, keyof Map<any, any>>, Map<string, DocSyncState> | (Map<string, {
+        status: "pending" | "syncing" | "synced" | "error" | "skipped";
+        lastSynced?: number | undefined;
+        error?: string | undefined;
+    }> & Omit<Map<string, DocSyncState>, keyof Map<any, any>>)>;
+    isSyncing: import("vue").Ref<boolean, boolean>;
+    syncedCount: import("vue").ComputedRef<number>;
+    errorCount: import("vue").ComputedRef<number>;
+    progress: import("vue").ComputedRef<number>;
+    lastCompletedAt: import("vue").Ref<number | null, number | null>;
+    syncNow: typeof syncNow;
+    syncDoc: typeof syncDoc;
+};
+export {};

package/dist/runtime/composables/useBackgroundSync.js

@@ -0,0 +1,73 @@
+import { ref, computed } from "vue";
+const syncStates = ref(/* @__PURE__ */ new Map());
+const isSyncing = ref(false);
+const lastCompletedAt = ref(null);
+let _manager = null;
+let _stopPeriodicSync = null;
+const syncedCount = computed(() => {
+  let n = 0;
+  for (const s of syncStates.value.values()) {
+    if (s.status === "synced") n++;
+  }
+  return n;
+});
+const errorCount = computed(() => {
+  let n = 0;
+  for (const s of syncStates.value.values()) {
+    if (s.status === "error") n++;
+  }
+  return n;
+});
+const progress = computed(() => {
+  const total = syncStates.value.size;
+  if (total === 0) return 0;
+  let done = 0;
+  for (const s of syncStates.value.values()) {
+    if (s.status === "synced" || s.status === "error" || s.status === "skipped") done++;
+  }
+  return Math.min(1, done / total);
+});
+export function _initBackgroundSync(manager, intervalMs = 5 * 60 * 1e3) {
+  _manager = manager;
+  const existing = _manager.getSyncStatus();
+  syncStates.value = new Map(existing);
+  _manager.on("stateChanged", ({ docId, state }) => {
+    syncStates.value = new Map(syncStates.value).set(docId, state);
+  });
+  _stopPeriodicSync = _manager.startPeriodicSync(intervalMs);
+}
+export function _destroyBackgroundSync() {
+  _stopPeriodicSync?.();
+  _stopPeriodicSync = null;
+  _manager?.destroy();
+  _manager = null;
+  syncStates.value = /* @__PURE__ */ new Map();
+  isSyncing.value = false;
+  lastCompletedAt.value = null;
+}
+async function syncNow() {
+  if (!_manager || isSyncing.value) return;
+  isSyncing.value = true;
+  try {
+    await _manager.syncAll();
+    lastCompletedAt.value = Date.now();
+  } finally {
+    isSyncing.value = false;
+  }
+}
+async function syncDoc(docId) {
+  if (!_manager) return;
+  await _manager.syncDoc(docId);
+}
+export function useBackgroundSync() {
+  return {
+    syncStates,
+    isSyncing,
+    syncedCount,
+    errorCount,
+    progress,
+    lastCompletedAt,
+    syncNow,
+    syncDoc
+  };
+}

package/dist/runtime/composables/useChat.d.ts

@@ -0,0 +1,65 @@
+/**
+ * useChat
+ *
+ * Real-time group and DM chat via provider.sendStateless().
+ * Wire _handleStatelessChat() into the provider's onStateless callback
+ * from the main plugin.
+ *
+ * Usage:
+ *   const { channels, sendMessage, setActiveChannel } = useChat()
+ *   const { messages, typingUsers } = useChatChannel('group:<docId>')
+ */
+export interface ChatMessage {
+    id: string;
+    channel: string;
+    senderId: string;
+    senderName: string;
+    content: string;
+    createdAt: number;
+}
+export interface ChatChannel {
+    id: string;
+    type: 'group' | 'dm';
+    label: string;
+    lastMessage?: ChatMessage;
+    unreadCount: number;
+}
+export declare function buildDmChannelId(a: string, b: string): string;
+declare let _publicKeyB64: import("vue").Ref<string, string>;
+declare let _userName: import("vue").Ref<string, string>;
+export declare function _initChat(publicKeyB64Ref: typeof _publicKeyB64, userNameRef: typeof _userName): void;
+export declare function _destroyChat(): void;
+export declare function _handleStatelessChat(payload: string): void;
+declare function sendMessage(channelId: string, content: string): void;
+declare function fetchHistory(channelId: string, opts?: {
+    before?: number;
+    limit?: number;
+}): void;
+declare function sendTyping(channelId: string): void;
+declare function setActiveChannel(channelId: string | null): void;
+export declare function useChat(): {
+    channels: import("vue").Ref<Record<string, ChatChannel>, Record<string, ChatChannel>>;
+    activeChannel: import("vue").Ref<string | null, string | null>;
+    messagesByChannel: import("vue").Ref<Record<string, ChatMessage[]>, Record<string, ChatMessage[]>>;
+    typingByChannel: import("vue").Ref<Record<string, Set<string>>, Record<string, Set<string>>>;
+    sendMessage: typeof sendMessage;
+    fetchHistory: typeof fetchHistory;
+    sendTyping: typeof sendTyping;
+    setActiveChannel: typeof setActiveChannel;
+    buildDmChannelId: typeof buildDmChannelId;
+};
+export declare function useChatChannel(channelId: string): {
+    messages: import("vue").ComputedRef<ChatMessage[]>;
+    channel: import("vue").ComputedRef<ChatChannel | undefined>;
+    typingUsers: import("vue").ComputedRef<string[]>;
+    unreadCount: import("vue").ComputedRef<number>;
+    send: (content: string) => void;
+    loadHistory: (opts?: {
+        before?: number;
+        limit?: number;
+    }) => void;
+    typing: () => void;
+    focus: () => void;
+    blur: () => void;
+};
+export {};

package/dist/runtime/composables/useChat.js

@@ -0,0 +1,210 @@
+import { ref, computed } from "vue";
+export function buildDmChannelId(a, b) {
+  return `dm:${[a, b].sort().join(":")}`;
+}
+const messagesByChannel = ref({});
+const channels = ref({});
+const typingByChannel = ref({});
+const activeChannel = ref(null);
+const typingTimers = /* @__PURE__ */ new Map();
+let _publicKeyB64 = ref("");
+let _userName = ref("");
+export function _initChat(publicKeyB64Ref, userNameRef) {
+  _publicKeyB64 = publicKeyB64Ref;
+  _userName = userNameRef;
+  messagesByChannel.value = {};
+  channels.value = {};
+  typingByChannel.value = {};
+  activeChannel.value = null;
+}
+export function _destroyChat() {
+  messagesByChannel.value = {};
+  channels.value = {};
+  typingByChannel.value = {};
+  activeChannel.value = null;
+  for (const t of typingTimers.values()) clearTimeout(t);
+  typingTimers.clear();
+}
+function resolveChannelLabel(channelId, senderName, senderId) {
+  const { doc } = useAbracadabra();
+  if (channelId.startsWith("group:")) {
+    const docId = channelId.slice("group:".length);
+    try {
+      const entry = doc.value?.getMap("doc-tree")?.get(docId);
+      if (entry?.label) return `${entry.label} Chat`;
+    } catch {
+    }
+    return "Group Chat";
+  }
+  if (channelId.startsWith("dm:")) {
+    if (senderName && senderId && senderId !== _publicKeyB64.value) return senderName;
+    const msgs = messagesByChannel.value[channelId];
+    if (msgs) {
+      const otherMsg = msgs.find((m) => m.senderId !== _publicKeyB64.value);
+      if (otherMsg) return otherMsg.senderName;
+    }
+  }
+  return channelId;
+}
+function ensureChannel(channelId, label) {
+  const resolvedLabel = label || resolveChannelLabel(channelId) || channelId;
+  if (!channels.value[channelId]) {
+    const type = channelId.startsWith("dm:") ? "dm" : "group";
+    channels.value = { ...channels.value, [channelId]: { id: channelId, type, label: resolvedLabel, unreadCount: 0 } };
+  } else if (channels.value[channelId].label === channelId && resolvedLabel !== channelId) {
+    channels.value = { ...channels.value, [channelId]: { ...channels.value[channelId], label: resolvedLabel } };
+  }
+}
+function addMessage(msg) {
+  const list = messagesByChannel.value[msg.channel] ?? [];
+  if (list.some((m) => m.id === msg.id)) return;
+  const sorted = [...list, msg].sort((a, b) => a.createdAt - b.createdAt);
+  messagesByChannel.value = { ...messagesByChannel.value, [msg.channel]: sorted };
+  const chan = channels.value[msg.channel];
+  if (chan) {
+    const isActive = activeChannel.value === msg.channel;
+    channels.value = {
+      ...channels.value,
+      [msg.channel]: {
+        ...chan,
+        lastMessage: msg,
+        unreadCount: isActive ? 0 : chan.unreadCount + 1
+      }
+    };
+  }
+}
+export function _handleStatelessChat(payload) {
+  if (!payload.includes('"chat:')) return;
+  try {
+    const data = JSON.parse(payload);
+    if (!data.type?.startsWith("chat:")) return;
+    switch (data.type) {
+      case "chat:history": {
+        const msgs = (data.messages || []).map((m) => ({
+          id: m.id,
+          channel: m.channel,
+          senderId: m.sender_id ?? "",
+          senderName: m.sender_name ?? "User",
+          content: m.content,
+          createdAt: typeof m.created_at === "number" ? m.created_at : new Date(m.created_at).getTime()
+        }));
+        for (const msg of msgs) {
+          ensureChannel(msg.channel, resolveChannelLabel(msg.channel, msg.senderName, msg.senderId));
+          addMessage(msg);
+        }
+        break;
+      }
+      case "chat:message": {
+        const msg = {
+          id: data.id ?? crypto.randomUUID(),
+          channel: data.channel,
+          senderId: data.sender_id ?? "",
+          senderName: data.sender_name ?? "User",
+          content: data.content,
+          createdAt: typeof data.created_at === "number" ? data.created_at : Date.now()
+        };
+        ensureChannel(msg.channel, resolveChannelLabel(msg.channel, msg.senderName, msg.senderId));
+        addMessage(msg);
+        const typing = typingByChannel.value[msg.channel];
+        if (typing?.has(msg.senderName)) {
+          const next = new Set(typing);
+          next.delete(msg.senderName);
+          typingByChannel.value = { ...typingByChannel.value, [msg.channel]: next };
+        }
+        break;
+      }
+      case "chat:typing": {
+        const channel = data.channel;
+        const name = data.sender_name ?? "User";
+        if (data.sender_id === _publicKeyB64.value) break;
+        const current = typingByChannel.value[channel] ?? /* @__PURE__ */ new Set();
+        const next = new Set(current).add(name);
+        typingByChannel.value = { ...typingByChannel.value, [channel]: next };
+        const timerKey = `${channel}:${name}`;
+        const existing = typingTimers.get(timerKey);
+        if (existing) clearTimeout(existing);
+        typingTimers.set(timerKey, setTimeout(() => {
+          typingTimers.delete(timerKey);
+          const cur = typingByChannel.value[channel];
+          if (!cur) return;
+          const updated = new Set(cur);
+          updated.delete(name);
+          typingByChannel.value = { ...typingByChannel.value, [channel]: updated };
+        }, 4e3));
+        break;
+      }
+    }
+  } catch {
+  }
+}
+function sendMessage(channelId, content) {
+  const { provider } = useAbracadabra();
+  if (!provider.value || !content.trim()) return;
+  provider.value.sendStateless(JSON.stringify({
+    type: "chat:send",
+    channel: channelId,
+    content: content.trim()
+  }));
+}
+function fetchHistory(channelId, opts) {
+  const { provider } = useAbracadabra();
+  if (!provider.value) return;
+  provider.value.sendStateless(JSON.stringify({
+    type: "chat:history",
+    channel: channelId,
+    before: opts?.before,
+    limit: opts?.limit ?? 50
+  }));
+}
+function sendTyping(channelId) {
+  const { provider } = useAbracadabra();
+  if (!provider.value) return;
+  provider.value.sendStateless(JSON.stringify({
+    type: "chat:typing",
+    channel: channelId
+  }));
+}
+function setActiveChannel(channelId) {
+  activeChannel.value = channelId;
+  if (channelId && channels.value[channelId]) {
+    channels.value = {
+      ...channels.value,
+      [channelId]: { ...channels.value[channelId], unreadCount: 0 }
+    };
+  }
+}
+export function useChat() {
+  return {
+    channels,
+    activeChannel,
+    messagesByChannel,
+    typingByChannel,
+    sendMessage,
+    fetchHistory,
+    sendTyping,
+    setActiveChannel,
+    buildDmChannelId
+  };
+}
+export function useChatChannel(channelId) {
+  const messages = computed(() => messagesByChannel.value[channelId] ?? []);
+  const channel = computed(() => channels.value[channelId]);
+  const typingUsers = computed(() => [...typingByChannel.value[channelId] ?? []]);
+  const unreadCount = computed(() => channels.value[channelId]?.unreadCount ?? 0);
+  function send(content) {
+    sendMessage(channelId, content);
+  }
+  function loadHistory(opts) {
+    fetchHistory(channelId, opts);
+  }
+  function typing() {
+    sendTyping(channelId);
+  }
+  function focus() {
+    setActiveChannel(channelId);
+  }
+  function blur() {
+    if (activeChannel.value === channelId) setActiveChannel(null);
+  }
+  return { messages, channel, typingUsers, unreadCount, send, loadHistory, typing, focus, blur };
+}

package/dist/runtime/composables/useChatUsers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * useChatUsers
+ *
+ * Maps awareness public keys to user appearance data (name, color, neutral).
+ * Provides `getUserAppearance(publicKey)` and `onlineUsers` — useful when
+ * rendering chat messages from users who may be offline.
+ *
+ * Usage:
+ *   const { getUserAppearance, onlineUsers } = useChatUsers()
+ */
+export interface ChatUserAppearance {
+    name: string;
+    color: string;
+    neutralName: string;
+    publicKey: string;
+    isOnline: boolean;
+}
+export declare function useChatUsers(): {
+    onlineUsers: import("vue").ComputedRef<ChatUserAppearance[]>;
+    getUserAppearance: (publicKey: string) => ChatUserAppearance;
+};

package/dist/runtime/composables/useChatUsers.js

@@ -0,0 +1,39 @@
+import { computed } from "vue";
+import { deriveColorFromPubKey } from "../types.js";
+export function useChatUsers() {
+  const { provider } = useAbracadabra();
+  const onlineUsers = computed(() => {
+    if (!provider.value?.awareness) return [];
+    const result = [];
+    try {
+      const states = provider.value.awareness.states;
+      for (const state of states.values()) {
+        const u = state.user;
+        if (u?.publicKey) {
+          result.push({
+            name: u.name ?? "Anonymous",
+            color: u.color ?? "#888",
+            neutralName: "zinc",
+            publicKey: u.publicKey,
+            isOnline: true
+          });
+        }
+      }
+    } catch {
+    }
+    return result;
+  });
+  function getUserAppearance(publicKey) {
+    const online = onlineUsers.value.find((u) => u.publicKey === publicKey);
+    if (online) return online;
+    const derived = deriveColorFromPubKey(publicKey);
+    return {
+      name: "User",
+      color: derived.hsl,
+      neutralName: derived.neutralName,
+      publicKey,
+      isOnline: false
+    };
+  }
+  return { onlineUsers, getUserAppearance };
+}

package/dist/runtime/composables/useChildTree.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Document tree management over the root Y.Doc's "doc-tree" Y.Map.
+ *
+ * Scoped to descendants of `parentDocId`. Items created here appear in
+ * document tree UIs automatically because all clients read the same Y.Map.
+ *
+ * - childrenOf(null)  → direct children of `parentDocId`
+ * - childrenOf(id)    → direct children of `id` (nested, e.g. kanban cards inside a column)
+ *
+ * Ported from cou-sh/app/composables/useChildTree.ts.
+ */
+import { type ShallowRef } from 'vue';
+import type * as Y from 'yjs';
+import type { DocPageMeta, TreeEntry } from '../types.js';
+export { type DocPageMeta, type TreeEntry } from '../types.js';
+export declare function useChildTree(rootDoc: ShallowRef<Y.Doc | null>, parentDocId: string): {
+    entries: import("vue").ComputedRef<TreeEntry[]>;
+    childrenOf: (parentId: string | null) => TreeEntry[];
+    descendantsOf: (id: string) => TreeEntry[];
+    createChild: (parentId: string | null, label: string, type?: string) => string;
+    moveEntry: (id: string, newParentId: string | null, newOrder: number) => void;
+    deleteEntry: (id: string) => void;
+    renameEntry: (id: string, label: string) => void;
+    updateMeta: (id: string, patch: Partial<DocPageMeta>) => void;
+    duplicateEntry: (id: string) => string;
+    treeMap: {
+        data: Record<string, {
+            label: string;
+            parentId: string | null;
+            order: number;
+            type?: string;
+            meta?: DocPageMeta;
+            createdAt?: number;
+            updatedAt?: number;
+        }>;
+        lastUpdateLocal: ShallowRef<boolean, boolean>;
+        set: (key: string, value: {
+            label: string;
+            parentId: string | null;
+            order: number;
+            type?: string;
+            meta?: DocPageMeta;
+            createdAt?: number;
+            updatedAt?: number;
+        }) => {
+            label: string;
+            parentId: string | null;
+            order: number;
+            type?: string;
+            meta?: DocPageMeta;
+            createdAt?: number;
+            updatedAt?: number;
+        } | undefined;
+        remove: (key: string) => void | undefined;
+        clear: () => void | undefined;
+        get: (key: string) => {
+            label: string;
+            parentId: string | null;
+            order: number;
+            type?: string;
+            meta?: DocPageMeta;
+            createdAt?: number;
+            updatedAt?: number;
+        } | undefined;
+        yMap: import("vue").ComputedRef<Y.Map<{
+            label: string;
+            parentId: string | null;
+            order: number;
+            type?: string;
+            meta?: DocPageMeta;
+            createdAt?: number;
+            updatedAt?: number;
+        }> | null>;
+    };
+    trashMap: {
+        data: Record<string, {
+            label: string;
+            parentId: string | null;
+            order: number;
+            type?: string;
+            meta?: DocPageMeta;
+            deletedAt: number;
+        }>;
+        lastUpdateLocal: ShallowRef<boolean, boolean>;
+        set: (key: string, value: {
+            label: string;
+            parentId: string | null;
+            order: number;
+            type?: string;
+            meta?: DocPageMeta;
+            deletedAt: number;
+        }) => {
+            label: string;
+            parentId: string | null;
+            order: number;
+            type?: string;
+            meta?: DocPageMeta;
+            deletedAt: number;
+        } | undefined;
+        remove: (key: string) => void | undefined;
+        clear: () => void | undefined;
+        get: (key: string) => {
+            label: string;
+            parentId: string | null;
+            order: number;
+            type?: string;
+            meta?: DocPageMeta;
+            deletedAt: number;
+        } | undefined;
+        yMap: import("vue").ComputedRef<Y.Map<{
+            label: string;
+            parentId: string | null;
+            order: number;
+            type?: string;
+            meta?: DocPageMeta;
+            deletedAt: number;
+        }> | null>;
+    };
+};