@abraca/nuxt 0.2.0 → 1.5.0

package/dist/runtime/composables/useIdentityDoc.js

@@ -0,0 +1,349 @@
+import { ref } from "vue";
+const SYNC_SERVER_KEY = "abracadabra_identity_sync_server";
+let _provider = null;
+let _initPromise = null;
+let _publicKey = null;
+let _signChallengeFn = null;
+const _ready = ref(false);
+const userName = ref(
+  typeof localStorage !== "undefined" && localStorage.getItem("abracadabra_username") || ""
+);
+const userColorName = ref(
+  typeof localStorage !== "undefined" && localStorage.getItem("abracadabra_usercolor") || "blue"
+);
+const neutralColorName = ref(
+  typeof localStorage !== "undefined" && localStorage.getItem("abracadabra_neutralcolor") || "zinc"
+);
+const securityTier = ref(
+  typeof localStorage !== "undefined" && localStorage.getItem("abracadabra_security_tier") || "standard"
+);
+async function init(publicKeyB64, signChallenge, opts) {
+  if (_initPromise) return _initPromise;
+  _publicKey = publicKeyB64;
+  _signChallengeFn = signChallenge ?? null;
+  _initPromise = _doInit(publicKeyB64, opts);
+  return _initPromise;
+}
+async function _doInit(publicKeyB64, opts) {
+  if (typeof window === "undefined") return;
+  const { IdentityDocProvider } = await import("@abraca/dabra");
+  const providerConfig = {
+    publicKey: publicKeyB64,
+    autoConnect: false,
+    disableOfflineStore: false
+  };
+  if (_signChallengeFn) {
+    providerConfig.cryptoIdentity = { publicKey: publicKeyB64 };
+    providerConfig.signChallenge = _signChallengeFn;
+  }
+  if (opts?.webrtc) {
+    providerConfig.webrtc = opts.webrtc;
+  }
+  _provider = new IdentityDocProvider(providerConfig);
+  await new Promise((resolve) => setTimeout(resolve, 50));
+  if (_provider.isEmpty()) {
+    _migrateFromLocalStorage(_provider);
+  }
+  _syncRefsFromDoc(_provider);
+  _observeDoc(_provider);
+  _ready.value = true;
+  const syncUrl = _getSyncServerUrl();
+  if (syncUrl) {
+    _provider.connectToServer("sync", syncUrl);
+  }
+}
+function _migrateFromLocalStorage(provider) {
+  const doc = provider.document;
+  doc.transact(() => {
+    const profile = doc.getMap("profile");
+    const storedName = localStorage.getItem("abracadabra_username");
+    if (storedName) profile.set("username", storedName);
+    const storedColor = localStorage.getItem("abracadabra_usercolor");
+    if (storedColor) profile.set("colorName", storedColor);
+    const storedNeutral = localStorage.getItem("abracadabra_neutralcolor");
+    if (storedNeutral) profile.set("neutralColorName", storedNeutral);
+    const serversMap = doc.getMap("servers");
+    try {
+      const raw = localStorage.getItem("abracadabra_servers");
+      if (raw) {
+        const servers = JSON.parse(raw);
+        for (const server of servers) {
+          const { Y: YModule } = provider;
+          const entry = new YModule.Map();
+          entry.set("label", server.label);
+          if (server.hubDocId) entry.set("hubDocId", server.hubDocId);
+          if (server.entryDocId) entry.set("entryDocId", server.entryDocId);
+          if (server.spacesEnabled) entry.set("spacesEnabled", server.spacesEnabled);
+          entry.set("addedAt", Date.now());
+          serversMap.set(server.url, entry);
+        }
+      }
+    } catch {
+    }
+    const spacesArr = doc.getArray("spaces");
+    try {
+      const raw = localStorage.getItem("abracadabra_space_registry");
+      if (raw) {
+        const spaces = JSON.parse(raw);
+        for (const space of spaces) {
+          const { Y: YModule } = provider;
+          const yMap = new YModule.Map();
+          yMap.set("id", space.id);
+          yMap.set("name", space.name);
+          if (space.description) yMap.set("description", space.description);
+          yMap.set("type", space.type);
+          yMap.set("serverUrl", space.serverUrl);
+          yMap.set("docId", space.docId);
+          if (space.remoteSpaceId) yMap.set("remoteSpaceId", space.remoteSpaceId);
+          yMap.set("visibility", space.visibility);
+          yMap.set("isHub", space.isHub);
+          yMap.set("order", space.order);
+          if (space.lastSyncedAt) yMap.set("lastSyncedAt", space.lastSyncedAt);
+          yMap.set("createdAt", space.createdAt);
+          spacesArr.push([yMap]);
+        }
+      }
+    } catch {
+    }
+  });
+}
+function _syncRefsFromDoc(provider) {
+  const profile = provider.profileMap;
+  userName.value = profile.get("username") || userName.value;
+  userColorName.value = profile.get("colorName") || userColorName.value;
+  neutralColorName.value = profile.get("neutralColorName") || neutralColorName.value;
+  const tier = profile.get("securityTier");
+  if (tier === "relaxed" || tier === "standard" || tier === "paranoid") {
+    securityTier.value = tier;
+  }
+}
+function _observeDoc(provider) {
+  const profile = provider.profileMap;
+  profile.observe((event) => {
+    for (const [key] of event.changes.keys) {
+      switch (key) {
+        case "username": {
+          const v = profile.get("username");
+          if (v && v !== userName.value) {
+            userName.value = v;
+            try {
+              localStorage.setItem("abracadabra_username", v);
+            } catch {
+            }
+          }
+          break;
+        }
+        case "colorName": {
+          const v = profile.get("colorName");
+          if (v && v !== userColorName.value) {
+            userColorName.value = v;
+            try {
+              localStorage.setItem("abracadabra_usercolor", v);
+            } catch {
+            }
+          }
+          break;
+        }
+        case "neutralColorName": {
+          const v = profile.get("neutralColorName");
+          if (v && v !== neutralColorName.value) {
+            neutralColorName.value = v;
+            try {
+              localStorage.setItem("abracadabra_neutralcolor", v);
+            } catch {
+            }
+          }
+          break;
+        }
+        case "securityTier": {
+          const v = profile.get("securityTier");
+          if (v && (v === "relaxed" || v === "standard" || v === "paranoid") && v !== securityTier.value) {
+            securityTier.value = v;
+            try {
+              localStorage.setItem("abracadabra_security_tier", v);
+            } catch {
+            }
+          }
+          break;
+        }
+      }
+    }
+  });
+}
+function setUserName(name) {
+  if (_provider) {
+    _provider.setProfile({ username: name });
+  } else {
+    userName.value = name;
+    try {
+      localStorage.setItem("abracadabra_username", name);
+    } catch {
+    }
+  }
+}
+function setUserColor(colorName) {
+  if (_provider) {
+    _provider.setProfile({ colorName });
+  } else {
+    userColorName.value = colorName;
+    try {
+      localStorage.setItem("abracadabra_usercolor", colorName);
+    } catch {
+    }
+  }
+}
+function setNeutralColor(colorName) {
+  if (_provider) {
+    _provider.setProfile({ neutralColorName: colorName });
+  } else {
+    neutralColorName.value = colorName;
+    try {
+      localStorage.setItem("abracadabra_neutralcolor", colorName);
+    } catch {
+    }
+  }
+}
+function setSecurityTier(tier) {
+  if (_provider) {
+    _provider.setProfile({ securityTier: tier });
+  } else {
+    securityTier.value = tier;
+    try {
+      localStorage.setItem("abracadabra_security_tier", tier);
+    } catch {
+    }
+  }
+}
+function getServers() {
+  if (!_provider) return /* @__PURE__ */ new Map();
+  return _provider.getServers();
+}
+function setServer(url, entry) {
+  _provider?.setServer(url, entry);
+}
+function removeServer(url) {
+  _provider?.removeServer(url);
+}
+function getSpaces() {
+  if (!_provider) return [];
+  return _provider.getSpaces();
+}
+function addSpace(space) {
+  _provider?.addSpace(space);
+}
+function removeSpace(spaceId) {
+  _provider?.removeSpace(spaceId);
+}
+function updateSpace(spaceId, updates) {
+  _provider?.updateSpace(spaceId, updates);
+}
+function observeSpaces(callback) {
+  if (!_provider) return () => {
+  };
+  return _provider.observeSpaces(callback);
+}
+function getDevices() {
+  if (!_provider) return /* @__PURE__ */ new Map();
+  return _provider.getDevices();
+}
+function getDevice(publicKey) {
+  if (!_provider) return void 0;
+  return _provider.getDevice(publicKey);
+}
+function addDevice(publicKey, opts) {
+  _provider?.addDevice(publicKey, opts);
+}
+function revokeDevice(publicKey, revokedBy) {
+  _provider?.revokeDevice(publicKey, revokedBy);
+}
+function observeDevices(callback) {
+  if (!_provider) return () => {
+  };
+  return _provider.observe("devices", callback);
+}
+function _getSyncServerUrl() {
+  if (typeof localStorage === "undefined") return null;
+  return localStorage.getItem(SYNC_SERVER_KEY);
+}
+function connectSyncServer(url) {
+  if (!_provider) return;
+  _provider.setSyncServer(url);
+}
+function disconnectSyncServer() {
+  if (!_provider) return;
+  _provider.setSyncServer(null);
+}
+function setSyncServerUrl(url) {
+  if (typeof localStorage === "undefined") return;
+  if (url) {
+    localStorage.setItem(SYNC_SERVER_KEY, url);
+    if (_provider) connectSyncServer(url);
+  } else {
+    localStorage.removeItem(SYNC_SERVER_KEY);
+    if (_provider) disconnectSyncServer();
+  }
+}
+function getSyncServerUrl() {
+  return _getSyncServerUrl();
+}
+function getDocument() {
+  return _provider?.document ?? null;
+}
+function getProvider() {
+  return _provider;
+}
+function destroy() {
+  if (_provider) {
+    try {
+      _provider.destroy();
+    } catch {
+    }
+    _provider = null;
+  }
+  _initPromise = null;
+  _publicKey = null;
+  _signChallengeFn = null;
+  _ready.value = false;
+}
+export function useIdentityDoc() {
+  return {
+    // State
+    ready: _ready,
+    userName,
+    userColorName,
+    neutralColorName,
+    securityTier,
+    // Lifecycle
+    init,
+    destroy,
+    // Profile setters
+    setUserName,
+    setUserColor,
+    setNeutralColor,
+    setSecurityTier,
+    // Servers
+    getServers,
+    setServer,
+    removeServer,
+    // Spaces
+    getSpaces,
+    addSpace,
+    removeSpace,
+    updateSpace,
+    observeSpaces,
+    // Devices
+    getDevices,
+    getDevice,
+    addDevice,
+    revokeDevice,
+    observeDevices,
+    // Server sync
+    connectSyncServer,
+    disconnectSyncServer,
+    setSyncServerUrl,
+    getSyncServerUrl,
+    // Raw access
+    getDocument,
+    getProvider
+  };
+}

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

@@ -0,0 +1,31 @@
+export interface ExternalPluginEntry {
+    url: string;
+    /** Plugin name from the loaded bundle's `plugin.name` field */
+    name: string;
+    label?: string;
+    version?: string;
+    description?: string;
+    enabled: boolean;
+    /** Error message from the last load attempt, if any */
+    error?: string;
+    installedAt: number;
+}
+/**
+ * Normalizes user-entered shorthand to a full CDN URL.
+ *
+ * Supported formats:
+ * - `npm:package-name[@version]` -> jsDelivr npm CDN
+ * - `github:user/repo[@branch]` -> jsDelivr GitHub CDN
+ * - Any other string is returned as-is (assumed to be a full URL)
+ */
+export declare function normalizePluginUrl(input: string): string;
+export declare function useInstalledPlugins(): {
+    entries: import("@vueuse/shared").RemovableRef<ExternalPluginEntry[]>;
+    install: (rawUrl: string) => void;
+    uninstall: (url: string) => void;
+    setEnabled: (url: string, enabled: boolean) => void;
+    updateMeta: (url: string, meta: Partial<ExternalPluginEntry>) => void;
+    disabledBuiltins: import("@vueuse/shared").RemovableRef<string[]>;
+    isBuiltinEnabled: (name: string) => boolean;
+    setBuiltinEnabled: (name: string, enabled: boolean) => void;
+};

package/dist/runtime/composables/useInstalledPlugins.js

@@ -0,0 +1,58 @@
+import { useLocalStorage } from "@vueuse/core";
+const STORAGE_KEY = "abracadabra_external_plugins";
+const DISABLED_BUILTINS_KEY = "abracadabra_disabled_builtins";
+export function normalizePluginUrl(input) {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("npm:")) {
+    const pkg = trimmed.slice(4);
+    return `https://cdn.jsdelivr.net/npm/${pkg}/dist/plugin.js`;
+  }
+  if (trimmed.startsWith("github:")) {
+    const repo = trimmed.slice(7);
+    return `https://cdn.jsdelivr.net/gh/${repo}/dist/plugin.js`;
+  }
+  return trimmed;
+}
+export function useInstalledPlugins() {
+  const entries = useLocalStorage(STORAGE_KEY, []);
+  const disabledBuiltins = useLocalStorage(DISABLED_BUILTINS_KEY, []);
+  function isBuiltinEnabled(name) {
+    return !disabledBuiltins.value.includes(name);
+  }
+  function setBuiltinEnabled(name, enabled) {
+    if (enabled) {
+      disabledBuiltins.value = disabledBuiltins.value.filter((n) => n !== name);
+    } else {
+      if (!disabledBuiltins.value.includes(name)) {
+        disabledBuiltins.value = [...disabledBuiltins.value, name];
+      }
+    }
+  }
+  function install(rawUrl) {
+    const url = normalizePluginUrl(rawUrl);
+    if (entries.value.some((e) => e.url === url)) return;
+    entries.value = [
+      ...entries.value,
+      { url, name: url, enabled: true, installedAt: Date.now() }
+    ];
+  }
+  function uninstall(url) {
+    entries.value = entries.value.filter((e) => e.url !== url);
+  }
+  function setEnabled(url, enabled) {
+    entries.value = entries.value.map((e) => e.url === url ? { ...e, enabled } : e);
+  }
+  function updateMeta(url, meta) {
+    entries.value = entries.value.map((e) => e.url === url ? { ...e, ...meta } : e);
+  }
+  return {
+    entries,
+    install,
+    uninstall,
+    setEnabled,
+    updateMeta,
+    disabledBuiltins,
+    isBuiltinEnabled,
+    setBuiltinEnabled
+  };
+}

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

@@ -0,0 +1,56 @@
+/**
+ * useInvites
+ *
+ * Focused composable for invite management. Wraps the invite methods
+ * from useAbracadabra() with reactive state for the invite list.
+ *
+ * Usage:
+ *   const { invites, create, revoke, redeem, refresh } = useInvites()
+ */
+export interface Invite {
+    code: string;
+    role: string;
+    uses: number;
+    max_uses: number | null;
+    expires_at: number | null;
+    created_at: number;
+}
+declare function refresh(): Promise<void>;
+declare function create(opts?: {
+    role?: string;
+    maxUses?: number;
+    expiresIn?: number;
+}): Promise<Invite>;
+declare function revoke(code: string): Promise<void>;
+declare function redeem(code: string): Promise<void>;
+export declare function useInvites(): {
+    /** Reactive list of invites. */
+    invites: import("vue").Ref<{
+        code: string;
+        role: string;
+        uses: number;
+        max_uses: number | null;
+        expires_at: number | null;
+        created_at: number;
+    }[], Invite[] | {
+        code: string;
+        role: string;
+        uses: number;
+        max_uses: number | null;
+        expires_at: number | null;
+        created_at: number;
+    }[]>;
+    /** Whether invite list is loading. */
+    loading: import("vue").Ref<boolean, boolean>;
+    /** Last error message. */
+    error: import("vue").Ref<string | null, string | null>;
+    /** Refresh the invite list from server. */
+    refresh: typeof refresh;
+    /** Create a new invite. */
+    create: typeof create;
+    /** Revoke an existing invite by code. */
+    revoke: typeof revoke;
+    /** Redeem an invite code. */
+    redeem: typeof redeem;
+};
+export {};

package/dist/runtime/composables/useInvites.js

@@ -0,0 +1,78 @@
+import { ref } from "vue";
+import { useAbracadabra } from "#imports";
+const invites = ref([]);
+const loading = ref(false);
+const error = ref(null);
+let _fetched = false;
+async function refresh() {
+  const abra = useAbracadabra();
+  if (!abra.client.value) return;
+  loading.value = true;
+  error.value = null;
+  try {
+    const result = await abra.listInvites();
+    invites.value = result ?? [];
+    _fetched = true;
+  } catch (e) {
+    error.value = e.message ?? "Failed to fetch invites";
+  } finally {
+    loading.value = false;
+  }
+}
+async function create(opts) {
+  const abra = useAbracadabra();
+  error.value = null;
+  try {
+    const result = await abra.createInvite(opts);
+    await refresh();
+    return result;
+  } catch (e) {
+    error.value = e.message ?? "Failed to create invite";
+    throw e;
+  }
+}
+async function revoke(code) {
+  const abra = useAbracadabra();
+  error.value = null;
+  try {
+    await abra.revokeInvite(code);
+    invites.value = invites.value.filter((i) => i.code !== code);
+  } catch (e) {
+    error.value = e.message ?? "Failed to revoke invite";
+    throw e;
+  }
+}
+async function redeem(code) {
+  const abra = useAbracadabra();
+  error.value = null;
+  try {
+    await abra.redeemInvite(code);
+  } catch (e) {
+    error.value = e.message ?? "Failed to redeem invite";
+    throw e;
+  }
+}
+export function useInvites() {
+  if (!_fetched && !loading.value) {
+    const abra = useAbracadabra();
+    if (abra.client.value) {
+      refresh();
+    }
+  }
+  return {
+    /** Reactive list of invites. */
+    invites,
+    /** Whether invite list is loading. */
+    loading,
+    /** Last error message. */
+    error,
+    /** Refresh the invite list from server. */
+    refresh,
+    /** Create a new invite. */
+    create,
+    /** Revoke an existing invite by code. */
+    revoke,
+    /** Redeem an invite code. */
+    redeem
+  };
+}

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

@@ -0,0 +1,25 @@
+interface PendingJoin {
+    server: string;
+    spaceId: string | null;
+    docId: string | null;
+    route: string;
+}
+export declare function useJoinLink(): {
+    pendingJoin: import("vue").Ref<{
+        server: string;
+        spaceId: string | null;
+        docId: string | null;
+        route: string;
+    } | null, PendingJoin | {
+        server: string;
+        spaceId: string | null;
+        docId: string | null;
+        route: string;
+    } | null>;
+    hasPendingJoin: import("vue").ComputedRef<boolean>;
+    buildShareUrl: (routePath: string) => string;
+    detectJoinLink: () => PendingJoin | null;
+    acceptJoin: () => Promise<PendingJoin | null>;
+    dismissJoin: () => void;
+};
+export {};

package/dist/runtime/composables/useJoinLink.js

@@ -0,0 +1,58 @@
+import { ref, computed } from "vue";
+import { useNuxtApp } from "#imports";
+const pendingJoin = ref(null);
+export function useJoinLink() {
+  const abra = useAbracadabra();
+  function buildShareUrl(routePath) {
+    if (typeof window === "undefined") return routePath;
+    const base = window.location.origin + routePath;
+    const serverUrl = abra.currentServerUrl.value;
+    if (!serverUrl) return base;
+    const url = new URL(base);
+    url.searchParams.set("server", serverUrl);
+    return url.toString();
+  }
+  function detectJoinLink() {
+    if (typeof window === "undefined") return null;
+    const urlParams = new URLSearchParams(window.location.search);
+    const server = urlParams.get("server");
+    if (!server) return null;
+    const spaceId = urlParams.get("space");
+    const docMatch = window.location.pathname.match(/\/doc\/([0-9a-f-]+)/);
+    const docId = docMatch?.[1] ?? null;
+    const route = window.location.pathname;
+    urlParams.delete("server");
+    urlParams.delete("space");
+    const cleanSearch = urlParams.toString();
+    const cleanUrl = window.location.pathname + (cleanSearch ? `?${cleanSearch}` : "") + window.location.hash;
+    history.replaceState(history.state, "", cleanUrl);
+    pendingJoin.value = { server, spaceId, docId, route };
+    return pendingJoin.value;
+  }
+  async function acceptJoin() {
+    if (!pendingJoin.value) return null;
+    const join = { ...pendingJoin.value };
+    try {
+      await abra.addServer(join.server);
+      await abra.refreshSpaces();
+    } catch {
+    }
+    pendingJoin.value = null;
+    return join;
+  }
+  function dismissJoin() {
+    pendingJoin.value = null;
+  }
+  const hasPendingJoin = computed(() => pendingJoin.value !== null);
+  return {
+    pendingJoin,
+    hasPendingJoin,
+    buildShareUrl,
+    detectJoinLink,
+    acceptJoin,
+    dismissJoin
+  };
+}
+function useAbracadabra() {
+  return useNuxtApp().$abracadabra;
+}

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

@@ -0,0 +1,31 @@
+import type { TreeEntry } from '../types.js';
+export interface MediaTrack {
+    id: string;
+    label: string;
+    docId: string;
+    uploadId: string;
+    mimeType: string;
+    duration?: number;
+    artist?: string;
+    album?: string;
+    genre?: string;
+    year?: number;
+    parentId: string | null;
+    parentLabel: string;
+    isVideo: boolean;
+}
+export interface MediaGroup {
+    id: string;
+    label: string;
+    items: MediaTrack[];
+}
+/**
+ * Extracts media tracks from a flat list of tree entries.
+ * Groups by parent label for playlist-style display.
+ */
+export declare function useMediaExtractor(entries: {
+    value: TreeEntry[];
+}, docLabel: string): {
+    mediaItems: import("vue").ComputedRef<MediaTrack[]>;
+    groupedMedia: import("vue").ComputedRef<MediaGroup[]>;
+};