@abraca/nuxt 0.3.0 → 1.6.0

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.js

@@ -1,4 +1,5 @@
 import { ref } from "vue";
+import { useAbracadabra } from "#imports";
 const invites = ref([]);
 const loading = ref(false);
 const error = ref(null);

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

package/dist/runtime/composables/useMediaExtractor.js

@@ -0,0 +1,46 @@
+import { computed } from "vue";
+function entryToTrack(entry, parentLabel) {
+  const meta = entry.meta;
+  if (!meta?.coverUploadId || !meta?.coverMimeType) return null;
+  const mime = meta.coverMimeType;
+  if (!mime.startsWith("audio/") && !mime.startsWith("video/")) return null;
+  return {
+    id: entry.id,
+    label: entry.label,
+    docId: meta.coverDocId ?? entry.id,
+    uploadId: meta.coverUploadId,
+    mimeType: mime,
+    duration: meta.mediaDuration,
+    artist: meta.mediaArtist,
+    album: meta.mediaAlbum,
+    genre: meta.mediaGenre,
+    year: meta.mediaYear,
+    parentId: entry.parentId,
+    parentLabel,
+    isVideo: mime.startsWith("video/")
+  };
+}
+export function useMediaExtractor(entries, docLabel) {
+  const mediaItems = computed(() => {
+    const tracks = [];
+    for (const entry of entries.value) {
+      const track = entryToTrack(entry, docLabel);
+      if (track) tracks.push(track);
+    }
+    return tracks;
+  });
+  const groupedMedia = computed(() => {
+    const groupMap = /* @__PURE__ */ new Map();
+    for (const track of mediaItems.value) {
+      const key = track.parentLabel;
+      let group = groupMap.get(key);
+      if (!group) {
+        group = { id: track.parentId ?? "ungrouped", label: key, items: [] };
+        groupMap.set(key, group);
+      }
+      group.items.push(track);
+    }
+    return Array.from(groupMap.values());
+  });
+  return { mediaItems, groupedMedia };
+}

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

@@ -0,0 +1,43 @@
+import type { Ref, ShallowRef } from 'vue';
+import type * as Y from 'yjs';
+import type { MediaTrack } from './useMediaExtractor.js';
+export interface UseMediaPlaybackOptions {
+    mediaElementRef: ShallowRef<HTMLAudioElement | HTMLVideoElement | null>;
+    childDoc: ShallowRef<Y.Doc | null>;
+    playlist: Ref<MediaTrack[]>;
+    repeatMode: Ref<string>;
+    shuffle: Ref<boolean>;
+    getBlobUrl: (docId: string, uploadId: string) => Promise<string | null>;
+    useSyncedMap: <T = any>(doc: ShallowRef<Y.Doc | null>, mapName: string) => {
+        data: Record<string, T>;
+        yMap: Ref<Y.Map<T> | null>;
+        set: (key: string, value: T) => void;
+        lastUpdateLocal: Ref<boolean>;
+    };
+    onTrackChange?: (track: MediaTrack) => void;
+}
+export declare function useMediaPlayback(options: UseMediaPlaybackOptions): {
+    currentTrack: import("vue").ComputedRef<MediaTrack | null>;
+    currentTrackIndex: import("vue").ComputedRef<number>;
+    isPlaying: import("vue").ComputedRef<boolean>;
+    currentTime: import("vue").ComputedRef<number>;
+    totalDuration: import("vue").ComputedRef<number>;
+    progressFraction: import("vue").ComputedRef<number>;
+    volume: import("vue").ComputedRef<number>;
+    isMuted: import("vue").ComputedRef<boolean>;
+    isLoading: import("vue").ComputedRef<boolean>;
+    currentBlobUrl: import("vue").ComputedRef<string | null>;
+    isSynced: import("vue").ComputedRef<boolean>;
+    syncData: Record<string, any>;
+    playTrack: (track: MediaTrack, startAt?: number) => Promise<void>;
+    togglePlay: () => void;
+    seek: (position: number) => void;
+    nextTrack: () => void;
+    prevTrack: () => void;
+    setVolume: (val: number) => void;
+    toggleMute: () => void;
+    joinSync: () => Promise<void>;
+    leaveSync: () => void;
+    onTrackEnded: () => void;
+    onLoadedMetadata: () => void;
+};