@abraca/nuxt 0.2.0 → 1.5.0

package/dist/runtime/composables/useBackgroundSync.js

@@ -1,9 +1,11 @@
 import { ref, computed } from "vue";
 const syncStates = ref(/* @__PURE__ */ new Map());
 const isSyncing = ref(false);
+const isPaused = ref(false);
 const lastCompletedAt = ref(null);
 let _manager = null;
 let _stopPeriodicSync = null;
+let _periodicIntervalMs = 5 * 60 * 1e3;
 const syncedCount = computed(() => {
   let n = 0;
   for (const s of syncStates.value.values()) {
@@ -29,12 +31,16 @@ const progress = computed(() => {
 });
 export function _initBackgroundSync(manager, intervalMs = 5 * 60 * 1e3) {
   _manager = manager;
-  const existing = _manager.getSyncStatus();
-  syncStates.value = new Map(existing);
+  _periodicIntervalMs = intervalMs;
   _manager.on("stateChanged", ({ docId, state }) => {
     syncStates.value = new Map(syncStates.value).set(docId, state);
   });
+  _manager.init().then(() => {
+    const existing = _manager.getSyncStatus();
+    syncStates.value = new Map(existing);
+  }).catch(() => null);
   _stopPeriodicSync = _manager.startPeriodicSync(intervalMs);
+  isPaused.value = false;
 }
 export function _destroyBackgroundSync() {
   _stopPeriodicSync?.();
@@ -43,8 +49,20 @@ export function _destroyBackgroundSync() {
   _manager = null;
   syncStates.value = /* @__PURE__ */ new Map();
   isSyncing.value = false;
+  isPaused.value = false;
   lastCompletedAt.value = null;
 }
+function pause() {
+  if (!_manager || isPaused.value) return;
+  _stopPeriodicSync?.();
+  _stopPeriodicSync = null;
+  isPaused.value = true;
+}
+function resume(intervalMs) {
+  if (!_manager || !isPaused.value) return;
+  _stopPeriodicSync = _manager.startPeriodicSync(intervalMs ?? _periodicIntervalMs);
+  isPaused.value = false;
+}
 async function syncNow() {
   if (!_manager || isSyncing.value) return;
   isSyncing.value = true;
@@ -63,11 +81,14 @@ export function useBackgroundSync() {
   return {
     syncStates,
     isSyncing,
+    isPaused,
     syncedCount,
     errorCount,
     progress,
     lastCompletedAt,
     syncNow,
-    syncDoc
+    syncDoc,
+    pause,
+    resume
   };
 }

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

@@ -0,0 +1,18 @@
+/**
+ * useBroadcastSync
+ *
+ * Wraps BroadcastChannelSync from @abraca/dabra for cross-tab Y.js sync.
+ * Initialized by the main plugin after root provider syncs.
+ * No user action needed — automatically syncs across browser tabs on the same origin.
+ *
+ * Usage:
+ *   const { isActive } = useBroadcastSync()
+ */
+import type * as Y from 'yjs';
+import type { Awareness } from 'y-protocols/awareness';
+export declare function _initBroadcastSync(BroadcastChannelSync: any, doc: Y.Doc, docId: string, awareness?: Awareness | null): void;
+export declare function _destroyBroadcastSync(): void;
+export declare function useBroadcastSync(): {
+    /** Whether cross-tab BroadcastChannel sync is currently active. */
+    isActive: import("vue").Ref<boolean, boolean>;
+};

package/dist/runtime/composables/useBroadcastSync.js

@@ -0,0 +1,26 @@
+import { ref } from "vue";
+const isActive = ref(false);
+let _sync = null;
+export function _initBroadcastSync(BroadcastChannelSync, doc, docId, awareness) {
+  _destroyBroadcastSync();
+  try {
+    _sync = BroadcastChannelSync.forDoc(doc, docId, awareness ?? void 0);
+    _sync.connect();
+    isActive.value = true;
+  } catch (e) {
+    console.error("[abracadabra] BroadcastChannelSync init failed:", e);
+  }
+}
+export function _destroyBroadcastSync() {
+  if (_sync) {
+    _sync.destroy();
+    _sync = null;
+  }
+  isActive.value = false;
+}
+export function useBroadcastSync() {
+  return {
+    /** Whether cross-tab BroadcastChannel sync is currently active. */
+    isActive
+  };
+}

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(":")}`;
 }
@@ -32,7 +33,8 @@ function resolveChannelLabel(channelId, senderName, senderId) {
     try {
       const entry = doc.value?.getMap("doc-tree")?.get(docId);
       if (entry?.label) return `${entry.label} Chat`;
-    } catch {
+    } catch (e) {
+      if (import.meta.dev) console.warn("[abracadabra] chat: failed to resolve channel label:", e);
     }
     return "Group Chat";
   }
@@ -106,35 +108,38 @@ 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;
       }
     }
-  } catch {
+  } catch (e) {
+    if (import.meta.dev) console.warn("[abracadabra] chat: failed to handle stateless message:", e);
   }
 }
 function sendMessage(channelId, content) {
@@ -173,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,
@@ -189,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(() => {
@@ -19,7 +20,8 @@ export function useChatUsers() {
           });
         }
       }
-    } catch {
+    } catch (e) {
+      if (import.meta.dev) console.warn("[abracadabra] chat-users: failed to read awareness states:", e);
     }
     return result;
   });

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[];