@abraca/nuxt 0.3.0 → 1.6.0

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

@@ -0,0 +1,86 @@
+import type { Ref } from 'vue';
+import type { TreeEntry } from './useChildTree.js';
+export type CalendarViewMode = 'month' | 'week' | 'day';
+export interface CalendarEvent {
+    id: string;
+    label: string;
+    color: string;
+    icon?: string;
+    datetimeStart: string;
+    datetimeEnd: string;
+    allDay: boolean;
+    entry: TreeEntry;
+}
+export interface LaneSlot {
+    type: 'empty' | 'span';
+    id?: string;
+    label?: string;
+    color?: string;
+    icon?: string;
+    isStart?: boolean;
+    isEnd?: boolean;
+}
+export interface CalendarCell {
+    date: Date | null;
+    dateStr: string | null;
+    isToday: boolean;
+    isCurrentMonth: boolean;
+    laneSlots: LaneSlot[];
+    events: CalendarEvent[];
+}
+export interface WeekRow {
+    cells: CalendarCell[];
+    laneCount: number;
+}
+export interface HourSlot {
+    hour: number;
+    label: string;
+    events: CalendarEvent[];
+}
+export interface DayColumn {
+    date: Date;
+    dateStr: string;
+    isToday: boolean;
+    label: string;
+    shortLabel: string;
+    allDayEvents: CalendarEvent[];
+    hourSlots: HourSlot[];
+}
+export interface UseCalendarViewOptions {
+    tree: {
+        childrenOf: (parentId: string | null) => TreeEntry[];
+    };
+    /** Stored view mode from doc meta */
+    storedView?: Ref<CalendarViewMode | undefined>;
+    /** 'sun' | 'mon' */
+    weekStartDay?: Ref<string>;
+    /** Whether to show week numbers */
+    showWeekNumbers?: Ref<boolean>;
+}
+declare function toDateStr(d: Date): string;
+export declare function useCalendarView(options: UseCalendarViewOptions): {
+    viewMode: Ref<CalendarViewMode, CalendarViewMode>;
+    isMobile: Ref<boolean, boolean>;
+    isTablet: Ref<boolean, boolean>;
+    currentDate: Ref<Date, Date>;
+    year: import("vue").ComputedRef<number>;
+    month: import("vue").ComputedRef<number>;
+    todayStr: import("vue").ComputedRef<string>;
+    periodLabel: import("vue").ComputedRef<string>;
+    prevPeriod: () => void;
+    nextPeriod: () => void;
+    goToday: () => void;
+    goToMonth: (y: number, m: number) => void;
+    weekStartOffset: import("vue").ComputedRef<1 | 0>;
+    weekDayHeaders: import("vue").ComputedRef<("Sun" | "Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat")[]>;
+    weekViewDays: import("vue").ComputedRef<3 | 7>;
+    weeks: import("vue").ComputedRef<WeekRow[]>;
+    weekNumbers: import("vue").ComputedRef<(number | null)[]>;
+    weekColumns: import("vue").ComputedRef<DayColumn[]>;
+    dayColumn: import("vue").ComputedRef<DayColumn>;
+    allEvents: import("vue").ComputedRef<CalendarEvent[]>;
+    unscheduledEntries: import("vue").ComputedRef<TreeEntry[]>;
+    toDateStr: typeof toDateStr;
+    cleanup: () => void;
+};
+export {};

package/dist/runtime/composables/useCalendarView.js

@@ -0,0 +1,316 @@
+import { ref, computed, onMounted } from "vue";
+const ALL_WEEK_DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+const HOURS_START = 0;
+const HOURS_END = 24;
+function toDateStr(d) {
+  return d.toISOString().slice(0, 10);
+}
+function isoWeekNumber(d) {
+  const date = new Date(d.getTime());
+  date.setHours(0, 0, 0, 0);
+  date.setDate(date.getDate() + 3 - (date.getDay() + 6) % 7);
+  const week1 = new Date(date.getFullYear(), 0, 4);
+  return 1 + Math.round(((date.getTime() - week1.getTime()) / 864e5 - 3 + (week1.getDay() + 6) % 7) / 7);
+}
+function parseEventTime(dt) {
+  const d = new Date(dt);
+  return { hour: d.getHours(), minute: d.getMinutes() };
+}
+export function useCalendarView(options) {
+  const { tree, storedView, weekStartDay, showWeekNumbers } = options;
+  const viewMode = ref("month");
+  const isMobile = ref(false);
+  const isTablet = ref(false);
+  function checkBreakpoints() {
+    if (typeof window === "undefined") return;
+    isMobile.value = window.innerWidth < 640;
+    isTablet.value = window.innerWidth >= 640 && window.innerWidth < 768;
+  }
+  onMounted(() => {
+    checkBreakpoints();
+    window.addEventListener("resize", checkBreakpoints);
+    const stored = storedView?.value;
+    if (stored) {
+      viewMode.value = stored;
+    } else if (isMobile.value) {
+      viewMode.value = "day";
+    } else if (isTablet.value) {
+      viewMode.value = "week";
+    }
+  });
+  const currentDate = ref(/* @__PURE__ */ new Date());
+  const year = computed(() => currentDate.value.getFullYear());
+  const month = computed(() => currentDate.value.getMonth());
+  const todayStr = computed(() => toDateStr(/* @__PURE__ */ new Date()));
+  const weekStartOffset = computed(
+    () => weekStartDay?.value === "mon" ? 1 : 0
+  );
+  const weekDayHeaders = computed(() => {
+    const o = weekStartOffset.value;
+    return [...ALL_WEEK_DAYS.slice(o), ...ALL_WEEK_DAYS.slice(0, o)];
+  });
+  const weekViewDays = computed(() => isMobile.value ? 3 : 7);
+  const periodLabel = computed(() => {
+    const d = currentDate.value;
+    const loc = typeof navigator !== "undefined" ? navigator.language : "en-US";
+    if (viewMode.value === "month") {
+      return d.toLocaleDateString(loc, { month: "long", year: "numeric" });
+    }
+    if (viewMode.value === "day") {
+      return d.toLocaleDateString(loc, { weekday: "long", month: "long", day: "numeric", year: "numeric" });
+    }
+    const start = weekStartDate.value;
+    const end = new Date(start);
+    end.setDate(end.getDate() + weekViewDays.value - 1);
+    const startStr = start.toLocaleDateString(loc, { month: "short", day: "numeric" });
+    const endStr = end.toLocaleDateString(loc, { month: "short", day: "numeric", year: "numeric" });
+    return `${startStr} \u2013 ${endStr}`;
+  });
+  function prevPeriod() {
+    const d = new Date(currentDate.value);
+    if (viewMode.value === "month") {
+      d.setMonth(d.getMonth() - 1);
+    } else if (viewMode.value === "week") {
+      d.setDate(d.getDate() - weekViewDays.value);
+    } else {
+      d.setDate(d.getDate() - 1);
+    }
+    currentDate.value = d;
+  }
+  function nextPeriod() {
+    const d = new Date(currentDate.value);
+    if (viewMode.value === "month") {
+      d.setMonth(d.getMonth() + 1);
+    } else if (viewMode.value === "week") {
+      d.setDate(d.getDate() + weekViewDays.value);
+    } else {
+      d.setDate(d.getDate() + 1);
+    }
+    currentDate.value = d;
+  }
+  function goToday() {
+    currentDate.value = /* @__PURE__ */ new Date();
+  }
+  function goToMonth(y, m) {
+    currentDate.value = new Date(y, m, 1);
+  }
+  function entryToEvent(entry) {
+    const start = entry.meta?.datetimeStart;
+    if (!start) return null;
+    return {
+      id: entry.id,
+      label: entry.label,
+      color: entry.meta?.color ?? "#6366f1",
+      icon: entry.meta?.icon,
+      datetimeStart: start,
+      datetimeEnd: entry.meta?.datetimeEnd ?? start,
+      allDay: !!entry.meta?.allDay,
+      entry
+    };
+  }
+  const allEvents = computed(() => {
+    const result = [];
+    for (const entry of tree.childrenOf(null)) {
+      const evt = entryToEvent(entry);
+      if (evt) result.push(evt);
+    }
+    return result;
+  });
+  const unscheduledEntries = computed(
+    () => tree.childrenOf(null).filter((e) => !e.meta?.datetimeStart)
+  );
+  const weeks = computed(() => {
+    const y = year.value;
+    const m = month.value;
+    const firstDay = (new Date(y, m, 1).getDay() - weekStartOffset.value + 7) % 7;
+    const daysInMonth = new Date(y, m + 1, 0).getDate();
+    const raw = [];
+    for (let i = firstDay - 1; i >= 0; i--) {
+      const date = new Date(y, m, -i);
+      const dateStr = toDateStr(date);
+      raw.push({ date, dateStr, isToday: dateStr === todayStr.value, isCurrentMonth: false });
+    }
+    for (let d = 1; d <= daysInMonth; d++) {
+      const date = new Date(y, m, d);
+      const dateStr = toDateStr(date);
+      raw.push({ date, dateStr, isToday: dateStr === todayStr.value, isCurrentMonth: true });
+    }
+    while (raw.length % 7 !== 0) {
+      const date = new Date(y, m + 1, raw.length - firstDay - daysInMonth + 1);
+      const dateStr = toDateStr(date);
+      raw.push({ date, dateStr, isToday: dateStr === todayStr.value, isCurrentMonth: false });
+    }
+    const entries = allEvents.value;
+    const result = [];
+    for (let wi = 0; wi < raw.length; wi += 7) {
+      const weekRaw = raw.slice(wi, wi + 7);
+      const weekDates = weekRaw.map((c) => c.dateStr);
+      const seenIds = /* @__PURE__ */ new Set();
+      const multiDay = [];
+      const singleDay = [];
+      for (const evt of entries) {
+        const start = evt.datetimeStart.slice(0, 10);
+        const end = evt.datetimeEnd.slice(0, 10);
+        const isMulti = start !== end;
+        let startCol = -1;
+        let endCol = -1;
+        for (let col = 0; col < 7; col++) {
+          const d = weekDates[col];
+          if (!d) continue;
+          if (d >= start && d <= end) {
+            if (startCol === -1) startCol = col;
+            endCol = col;
+          }
+        }
+        if (startCol === -1 || seenIds.has(evt.id)) continue;
+        seenIds.add(evt.id);
+        if (isMulti || evt.allDay) {
+          multiDay.push({
+            id: evt.id,
+            label: evt.label,
+            color: evt.color,
+            icon: evt.icon,
+            startCol,
+            endCol,
+            globalStart: start,
+            entry: evt.entry
+          });
+        } else {
+          singleDay.push({ ...evt, col: startCol });
+        }
+      }
+      multiDay.sort(
+        (a, b) => a.startCol - b.startCol || b.endCol - b.startCol - (a.endCol - a.startCol) || a.globalStart.localeCompare(b.globalStart)
+      );
+      const lanes = [];
+      const assigned = [];
+      for (const evt of multiDay) {
+        let lane = lanes.findIndex((lastEnd) => lastEnd < evt.startCol);
+        if (lane === -1) {
+          lane = lanes.length;
+          lanes.push(-1);
+        }
+        lanes[lane] = evt.endCol;
+        assigned.push({ ...evt, lane });
+      }
+      const laneCount = lanes.length;
+      const cells = weekRaw.map((r, col) => {
+        const laneSlots = [];
+        for (let l = 0; l < laneCount; l++) {
+          const span = assigned.find(
+            (s) => s.lane === l && col >= s.startCol && col <= s.endCol
+          );
+          if (span) {
+            laneSlots.push({
+              type: "span",
+              id: span.id,
+              label: span.label,
+              color: span.color,
+              icon: span.icon,
+              isStart: col === span.startCol,
+              isEnd: col === span.endCol
+            });
+          } else {
+            laneSlots.push({ type: "empty" });
+          }
+        }
+        const events = singleDay.filter((e) => e.col === col);
+        return { ...r, laneSlots, events, isCurrentMonth: r.isCurrentMonth };
+      });
+      result.push({ cells, laneCount });
+    }
+    return result;
+  });
+  const weekNumbers = computed(() => {
+    if (!showWeekNumbers?.value) return [];
+    return weeks.value.map((week) => {
+      const firstDate = week.cells.find((c) => c.date)?.date;
+      return firstDate ? isoWeekNumber(firstDate) : null;
+    });
+  });
+  const weekStartDate = computed(() => {
+    const d = new Date(currentDate.value);
+    const dayOfWeek = (d.getDay() - weekStartOffset.value + 7) % 7;
+    d.setDate(d.getDate() - dayOfWeek);
+    d.setHours(0, 0, 0, 0);
+    return d;
+  });
+  function buildDayColumn(date) {
+    const dateStr = toDateStr(date);
+    const loc = typeof navigator !== "undefined" ? navigator.language : "en-US";
+    const isToday = dateStr === todayStr.value;
+    const dayEvents = allEvents.value.filter((evt) => {
+      const evtStart = evt.datetimeStart.slice(0, 10);
+      const evtEnd = evt.datetimeEnd.slice(0, 10);
+      return dateStr >= evtStart && dateStr <= evtEnd;
+    });
+    const allDayEvents = dayEvents.filter((e) => e.allDay);
+    const timedEvents = dayEvents.filter((e) => !e.allDay);
+    const hourSlots = [];
+    for (let h = HOURS_START; h < HOURS_END; h++) {
+      const eventsInHour = timedEvents.filter((evt) => {
+        const start = parseEventTime(evt.datetimeStart);
+        const end = parseEventTime(evt.datetimeEnd);
+        return start.hour <= h && (end.hour > h || end.hour === h && end.minute > 0);
+      });
+      hourSlots.push({
+        hour: h,
+        label: `${h.toString().padStart(2, "0")}:00`,
+        events: eventsInHour
+      });
+    }
+    return {
+      date,
+      dateStr,
+      isToday,
+      label: date.toLocaleDateString(loc, { weekday: "long", month: "short", day: "numeric" }),
+      shortLabel: date.toLocaleDateString(loc, { weekday: "short", day: "numeric" }),
+      allDayEvents,
+      hourSlots
+    };
+  }
+  const weekColumns = computed(() => {
+    const start = weekStartDate.value;
+    const cols = [];
+    const count = weekViewDays.value;
+    for (let i = 0; i < count; i++) {
+      const d = new Date(start);
+      d.setDate(d.getDate() + i);
+      cols.push(buildDayColumn(d));
+    }
+    return cols;
+  });
+  const dayColumn = computed(
+    () => buildDayColumn(currentDate.value)
+  );
+  function cleanup() {
+    if (typeof window !== "undefined") {
+      window.removeEventListener("resize", checkBreakpoints);
+    }
+  }
+  return {
+    viewMode,
+    isMobile,
+    isTablet,
+    currentDate,
+    year,
+    month,
+    todayStr,
+    periodLabel,
+    prevPeriod,
+    nextPeriod,
+    goToday,
+    goToMonth,
+    weekStartOffset,
+    weekDayHeaders,
+    weekViewDays,
+    weeks,
+    weekNumbers,
+    weekColumns,
+    dayColumn,
+    allEvents,
+    unscheduledEntries,
+    toDateStr,
+    cleanup
+  };
+}

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

@@ -41,7 +41,8 @@ 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>>>;
+    typingByChannel: import("vue").Ref<Record<string, Map<string, string>>, Record<string, Map<string, string>>>;
+    totalUnreadCount: import("vue").ComputedRef<number>;
     sendMessage: typeof sendMessage;
     fetchHistory: typeof fetchHistory;
     sendTyping: typeof sendTyping;

package/dist/runtime/composables/useChat.js

@@ -1,4 +1,5 @@
 import { ref, computed } from "vue";
+import { useAbracadabra } from "./useAbracadabra.js";
 export function buildDmChannelId(a, b) {
   return `dm:${[a, b].sort().join(":")}`;
 }
@@ -107,29 +108,31 @@ export function _handleStatelessChat(payload) {
         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);
+        if (typing?.has(msg.senderId)) {
+          const next = new Map(typing);
+          next.delete(msg.senderId);
           typingByChannel.value = { ...typingByChannel.value, [msg.channel]: next };
         }
         break;
       }
       case "chat:typing": {
         const channel = data.channel;
+        const senderId = data.sender_id ?? "";
         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);
+        if (senderId === _publicKeyB64.value) break;
+        const current = typingByChannel.value[channel] ?? /* @__PURE__ */ new Map();
+        const next = new Map(current);
+        next.set(senderId, name);
         typingByChannel.value = { ...typingByChannel.value, [channel]: next };
-        const timerKey = `${channel}:${name}`;
+        const timerKey = `${channel}:${senderId}`;
         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);
+          const updated = new Map(cur);
+          updated.delete(senderId);
           typingByChannel.value = { ...typingByChannel.value, [channel]: updated };
         }, 4e3));
         break;
@@ -175,12 +178,16 @@ function setActiveChannel(channelId) {
     };
   }
 }
+const totalUnreadCount = computed(
+  () => Object.values(channels.value).reduce((sum, ch) => sum + ch.unreadCount, 0)
+);
 export function useChat() {
   return {
     channels,
     activeChannel,
     messagesByChannel,
     typingByChannel,
+    totalUnreadCount,
     sendMessage,
     fetchHistory,
     sendTyping,
@@ -191,7 +198,7 @@ export function useChat() {
 export function useChatChannel(channelId) {
   const messages = computed(() => messagesByChannel.value[channelId] ?? []);
   const channel = computed(() => channels.value[channelId]);
-  const typingUsers = computed(() => [...typingByChannel.value[channelId] ?? []]);
+  const typingUsers = computed(() => [...typingByChannel.value[channelId]?.values() ?? []]);
   const unreadCount = computed(() => channels.value[channelId]?.unreadCount ?? 0);
   function send(content) {
     sendMessage(channelId, content);

package/dist/runtime/composables/useChatUsers.js

@@ -1,5 +1,6 @@
 import { computed } from "vue";
 import { deriveColorFromPubKey } from "../types.js";
+import { useAbracadabra } from "./useAbracadabra.js";
 export function useChatUsers() {
   const { provider } = useAbracadabra();
   const onlineUsers = computed(() => {

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

@@ -12,8 +12,10 @@
 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): {
+export { type DocPageMeta, type TreeEntry, type TableColumnDef } from '../types.js';
+export declare function useChildTree(rootDoc: ShallowRef<Y.Doc | null>, parentDocId: string, options?: {
+    isSpaceRoot?: boolean;
+}): {
     entries: import("vue").ComputedRef<TreeEntry[]>;
     childrenOf: (parentId: string | null) => TreeEntry[];
     descendantsOf: (id: string) => TreeEntry[];

package/dist/runtime/composables/useChildTree.js

@@ -1,20 +1,28 @@
 import { computed } from "vue";
 import { useSyncedMap } from "./useYDoc.js";
-export function useChildTree(rootDoc, parentDocId) {
+import { isDescendantInMap } from "../utils/docDragDrop.js";
+export function useChildTree(rootDoc, parentDocId, options) {
   const treeMap = useSyncedMap(rootDoc, "doc-tree");
   const trashMap = useSyncedMap(rootDoc, "doc-trash");
-  const entries = computed(
-    () => Object.entries(treeMap.data).map(([id, v]) => ({
-      id,
-      label: v.label || "Untitled",
-      parentId: v.parentId ?? null,
-      order: v.order ?? 0,
-      type: v.type,
-      meta: v.meta,
-      createdAt: v.createdAt,
-      updatedAt: v.updatedAt
-    }))
-  );
+  const entries = computed(() => {
+    const result = [];
+    for (const [id, v] of Object.entries(treeMap.data)) {
+      if (id === parentDocId && options?.isSpaceRoot) continue;
+      let pid = v.parentId ?? null;
+      if (options?.isSpaceRoot && pid === null) pid = parentDocId;
+      result.push({
+        id,
+        label: v.label || "Untitled",
+        parentId: pid,
+        order: v.order ?? 0,
+        type: v.type,
+        meta: v.meta,
+        createdAt: v.createdAt,
+        updatedAt: v.updatedAt
+      });
+    }
+    return result;
+  });
   function childrenOf(parentId) {
     const target = parentId === null ? parentDocId : parentId;
     return entries.value.filter((e) => e.parentId === target).sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
@@ -45,14 +53,16 @@ export function useChildTree(rootDoc, parentDocId) {
   }
   function moveEntry(id, newParentId, newOrder) {
     const entry = treeMap.get(id);
-    if (entry) {
-      treeMap.set(id, {
-        ...entry,
-        parentId: newParentId === null ? parentDocId : newParentId,
-        order: newOrder,
-        updatedAt: Date.now()
-      });
-    }
+    if (!entry) return;
+    const resolvedParent = newParentId === null ? parentDocId : newParentId;
+    if (resolvedParent === id) return;
+    if (isDescendantInMap(treeMap.data, id, resolvedParent)) return;
+    treeMap.set(id, {
+      ...entry,
+      parentId: resolvedParent,
+      order: newOrder,
+      updatedAt: Date.now()
+    });
   }
   function deleteEntry(id) {
     const doc = rootDoc.value;

package/dist/runtime/composables/useCommandPalette.js

@@ -1,5 +1,6 @@
 import { ref, watch } from "vue";
 import { useLocalStorage } from "@vueuse/core";
+import { useAbracadabra, usePluginRegistry, useDocSlugs, navigateTo } from "#imports";
 const isOpen = ref(false);
 const searchTerm = ref("");
 export function useCommandPalette() {
@@ -115,23 +116,21 @@ export function useCommandPalette() {
     }
     try {
       const ctx = { doc, provider, abracadabra: useAbracadabra(), searchTerm: searchTerm.value };
-      const pluginGroups = await registry.getAllCommandPaletteItems(ctx);
-      for (const group of pluginGroups) {
-        const filtered = (group.items ?? []).filter((item) => !q || item.label?.toLowerCase().includes(q)).map((item) => ({
-          id: item.id ?? `${group.id ?? "plugin"}:${item.label}`,
-          label: item.label,
-          icon: item.icon,
-          suffix: item.suffix,
-          shortcut: item.shortcut,
-          onClick: () => {
-            item.action?.();
-            close();
-          },
-          disabled: item.disabled
-        }));
-        if (filtered.length > 0) {
-          result.push({ id: group.id ?? "plugin", label: group.label, items: filtered });
-        }
+      const pluginItems = await registry.getAllCommandPaletteItems(ctx);
+      const filtered = pluginItems.filter((item) => !q || item.label?.toLowerCase().includes(q)).map((item) => ({
+        id: item.id ?? `plugin:${item.label}`,
+        label: item.label,
+        icon: item.icon,
+        suffix: item.suffix,
+        shortcut: item.shortcut,
+        onClick: () => {
+          item.handler?.(ctx);
+          close();
+        },
+        disabled: item.disabled
+      }));
+      if (filtered.length > 0) {
+        result.push({ id: "plugin", label: "Plugins", items: filtered });
       }
     } catch (e) {
       if (import.meta.dev) console.warn("[abracadabra] command palette: failed to load plugin commands:", e);

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

@@ -15,7 +15,7 @@ type ConnectionStatusValue = 'disconnected' | 'connecting' | 'connected' | 'offl
  */
 export declare function useConnectionStatus(status?: MaybeRef<ConnectionStatusValue | string | undefined>, synced?: MaybeRef<boolean | undefined>): {
     label: import("vue").ComputedRef<string>;
-    color: import("vue").ComputedRef<"success" | "warning" | "error">;
+    color: import("vue").ComputedRef<"error" | "success" | "warning">;
     icon: import("vue").ComputedRef<"i-lucide-cloud-check" | "i-lucide-cloud" | "i-lucide-cloud-off">;
 };
 export {};

package/dist/runtime/composables/useConnectionStatus.js

@@ -9,7 +9,7 @@ export function useConnectionStatus(status, synced) {
     if (status !== void 0) return toValue(status) ?? "disconnected";
     return abra.status?.value ?? "disconnected";
   });
-  const resolvedSynced = computed(() => {
+  const _resolvedSynced = computed(() => {
     if (synced !== void 0) return toValue(synced) ?? false;
     const isSynced = abra.synced?.value ?? false;
     if (isSynced) return true;

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

@@ -0,0 +1,11 @@
+/**
+ * Syncs a Y.Doc across multiple browser tabs that have the same
+ * document open. Uses BroadcastChannel so that document updates
+ * propagate instantly between same-origin windows without waiting
+ * for the server round-trip.
+ *
+ * Ported from cou-sh/app/composables/useCrossWindowSync.ts.
+ */
+import { type Ref } from 'vue';
+import * as Y from 'yjs';
+export declare function useCrossWindowSync(doc: Ref<Y.Doc | null>, docId: Ref<string>): void;