@abraca/nuxt 0.1.0

package/dist/runtime/types.d.ts

@@ -0,0 +1,444 @@
+import type { ShallowRef, Ref, Component } from 'vue';
+import type { Extension } from '@tiptap/core';
+import type { Editor } from '@tiptap/vue-3';
+import type * as Y from 'yjs';
+/**
+ * An Abracadabra plugin contributes editor extensions, page types, toolbar items,
+ * slash commands, mentions, awareness fields, command palette items, and more.
+ *
+ * Plugins are registered before the registry is frozen at boot.
+ * After freezing all contributions are stable for the lifetime of the app.
+ */
+export interface AbracadabraPlugin {
+    /** Unique slug — must be stable across versions, e.g. 'core', 'kanban', 'my-plugin' */
+    name: string;
+    label?: string;
+    version?: string;
+    description?: string;
+    /** TipTap extensions (nodes, marks, extensions) contributed by this plugin */
+    extensions?: () => Extension[];
+    /**
+     * Optional promise that resolves when this plugin's extensions are fully
+     * loaded. Used by PluginRegistry.waitForExtensions() to ensure the editor
+     * doesn't initialize before async extension bundles are ready.
+     */
+    extensionsReady?: Promise<void>;
+    /** Document/page type renderers keyed by type slug */
+    pageTypes?: Record<string, AbracadabraPageType>;
+    /** Extra toolbar item groups appended after the built-in toolbar groups */
+    toolbarItems?: (ctx: EditorPluginCtx) => AbracadabraToolbarItem[][];
+    /** Extra bubble menu item groups (appear on text selection) */
+    bubbleMenuItems?: (ctx: EditorPluginCtx) => AbracadabraToolbarItem[][];
+    /** Slash command (/) suggestion menu item groups */
+    suggestionItems?: (ctx: EditorPluginCtx) => AbracadabraSuggestionItem[][];
+    /** Extra drag-handle menu items (per-block context menu) */
+    dragHandleItems?: (ctx: DragHandlePluginCtx) => AbracadabraDragHandleItem[][];
+    /** Custom editor handlers merged into UEditorCustomHandlers */
+    customHandlers?: () => Record<string, (...args: any[]) => any>;
+    /** Mention (@) providers contributing items to the mention popup */
+    mentionProviders?: AbracadabraMentionProvider[];
+    /** Awareness field declarations — keys this plugin reads/writes on awareness */
+    awarenessContributions?: AbracadabraAwarenessContribution[];
+    /** Global command palette (⌘K) items */
+    commandPaletteItems?: (ctx: CommandPaletteCtx) => AbracadabraCommandItem[] | Promise<AbracadabraCommandItem[]>;
+    /** Extra tabs rendered in the child document slideover panel */
+    nodePanelSlots?: AbracadabraNodePanelSlot[];
+    /** Settings panel contributed to the global settings view */
+    settingsPanel?: AbracadabraSettingsPanel;
+    /** Global keyboard shortcuts registered on document (not inside TipTap scope) */
+    keyboardShortcuts?: AbracadabraKeyboardShortcut[];
+    /**
+     * Client-side setup hook — called once after client + provider are ready.
+     * May return a teardown function called on app unmount.
+     */
+    clientSetup?: (ctx: ClientPluginCtx) => void | Promise<void | (() => void)>;
+    /** TipTap extensions safe for server-side Y.Doc → HTML rendering (no Vue NodeViews) */
+    serverExtensions?: () => Extension[];
+    /**
+     * Custom cache renderer for non-doc page types.
+     * Receives the Y.Doc and returns serializable data for the cache.
+     */
+    serverCacheRenderer?: (docId: string, ydoc: Y.Doc) => any;
+    /**
+     * Server-side background runners (Nitro context).
+     * Each runner receives a ServerRunnerContext and returns a cleanup function.
+     * Called once after the service provider syncs with the root document.
+     *
+     * Requires service credentials configured in module options
+     * (NUXT_ABRACADABRA_SERVICE_PUBLIC_KEY + NUXT_ABRACADABRA_SERVICE_PRIVATE_KEY).
+     */
+    serverRunners?: ServerRunnerDefinition[];
+}
+/** Context passed to editor-scoped plugin hooks */
+export interface EditorPluginCtx {
+    /** The TipTap Editor instance — shallowRef, do NOT deep-watch */
+    editor: ShallowRef<Editor | null>;
+    docId: string;
+}
+/** Context passed to drag-handle plugin hooks */
+export interface DragHandlePluginCtx extends EditorPluginCtx {
+    selectedNode: Ref<{
+        node: any | null;
+        pos: number;
+    } | undefined>;
+}
+/** Context passed to the plugin's clientSetup hook */
+export interface ClientPluginCtx {
+    /** Full reactive Abracadabra state (same as useAbracadabra()) */
+    abracadabra: AbracadabraState;
+}
+export interface AbracadabraPageType {
+    /** Human-readable label shown in the "create document" UI */
+    label: string;
+    /** Lucide icon name, e.g. 'file-text', 'kanban', 'calendar' */
+    icon: string;
+    /**
+     * Vue component that renders this document type.
+     * Wrap in defineAsyncComponent for code splitting.
+     */
+    component: Component;
+    /**
+     * Whether this page type uses the TipTap editor.
+     * Controls toolbar visibility. Default: false.
+     */
+    hasEditor?: boolean;
+    /** Metadata fields shown/edited in the document panel sidebar */
+    metaFields?: AbracadabraMetaField[];
+}
+export interface AbracadabraToolbarItem {
+    id: string;
+    label: string;
+    icon: string;
+    active?: (ctx: EditorPluginCtx) => boolean;
+    disabled?: (ctx: EditorPluginCtx) => boolean;
+    action: (ctx: EditorPluginCtx) => void;
+    /** Keyboard shortcut hint displayed in the tooltip */
+    shortcut?: string;
+}
+export interface AbracadabraSuggestionItem {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    action: (ctx: EditorPluginCtx) => void;
+}
+export interface AbracadabraDragHandleItem {
+    id: string;
+    label: string;
+    icon?: string;
+    action: (ctx: DragHandlePluginCtx) => void;
+}
+export interface CommandPaletteCtx {
+    docId: string | null;
+    router: any;
+    abracadabra: any;
+    tree: any | null;
+}
+export interface AbracadabraCommandItem {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    group?: string;
+    shortcut?: string;
+    when?: (ctx: CommandPaletteCtx) => boolean;
+    handler: (ctx: CommandPaletteCtx) => void | Promise<void>;
+}
+export interface AbracadabraMentionProvider {
+    /** Group label shown in the suggestion popup */
+    label: string;
+    getItems: (query: string, ctx: MentionPluginCtx) => AbracadabraMentionItem[] | Promise<AbracadabraMentionItem[]>;
+}
+export interface MentionPluginCtx {
+    docId: string;
+    connectedUsers: CollaborationUser[];
+    rootDoc: any;
+}
+export interface AbracadabraMentionItem {
+    id: string;
+    label: string;
+    avatar?: string;
+    color?: string;
+    attrs?: Record<string, any>;
+}
+export interface AbracadabraAwarenessContribution {
+    /** Namespaced keys this plugin writes, e.g. ['cursor', 'presence:kanban'] */
+    keys: string[];
+    /** Optional per-canvas cursor overlay component */
+    cursorComponent?: Component;
+}
+export interface AbracadabraNodePanelSlot {
+    id: string;
+    label: string;
+    icon: string;
+    when: (ctx: NodePanelCtx) => boolean;
+    component: Component;
+}
+export interface NodePanelCtx {
+    childId: string;
+    childDoc: any | null;
+    parentDocId: string;
+    parentType: string | undefined;
+    meta: Record<string, any>;
+    tree: any;
+}
+export interface AbracadabraSettingsPanel {
+    label: string;
+    icon: string;
+    component: Component;
+}
+export interface AbracadabraKeyboardShortcut {
+    /** e.g. 'Meta+Shift+K', 'Control+Alt+P' */
+    key: string;
+    description: string;
+    handler: () => void | Promise<void>;
+}
+export interface AbracadabraMetaField {
+    id: string;
+    type: string;
+    label?: string;
+    key?: string;
+    options?: string[];
+    min?: number;
+    max?: number;
+}
+export interface UserMetaField {
+    id: string;
+    type: string;
+    label?: string;
+    key?: string;
+    latKey?: string;
+    lngKey?: string;
+    startKey?: string;
+    endKey?: string;
+    allDayKey?: string;
+    presets?: string[];
+    options?: string[];
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+}
+export interface DocPageMeta extends Record<string, unknown> {
+    color?: string;
+    icon?: string;
+    datetimeStart?: string;
+    datetimeEnd?: string;
+    allDay?: boolean;
+    dateStart?: string;
+    dateEnd?: string;
+    timeStart?: string;
+    timeEnd?: string;
+    taskProgress?: number;
+    tags?: string[];
+    checked?: boolean;
+    priority?: number;
+    status?: string;
+    rating?: number;
+    url?: string;
+    email?: string;
+    phone?: string;
+    number?: number;
+    unit?: string;
+    subtitle?: string;
+    note?: string;
+    coverUploadId?: string;
+    coverDocId?: string;
+    coverMimeType?: string;
+    geoType?: 'marker' | 'line' | 'measure';
+    geoLat?: number;
+    geoLng?: number;
+    geoDescription?: string;
+    deskX?: number;
+    deskY?: number;
+    deskMode?: string;
+    mmX?: number;
+    mmY?: number;
+    graphX?: number;
+    graphY?: number;
+    graphPinned?: boolean;
+    _metaFields?: UserMetaField[];
+    _metaInitialized?: boolean;
+}
+export interface TreeEntry {
+    id: string;
+    label: string;
+    parentId: string | null;
+    order: number;
+    type?: string;
+    meta?: DocPageMeta;
+    createdAt?: number;
+    updatedAt?: number;
+}
+export interface CollaborationUser {
+    name: string;
+    color: string;
+    publicKey?: string;
+    docId?: string;
+}
+export interface AwarenessUser {
+    clientId: number;
+    user?: {
+        name?: string;
+        color?: string;
+        avatar?: string;
+    };
+    /** Which document this user is currently viewing */
+    docId?: string;
+    [key: string]: any;
+}
+/**
+ * Enriched awareness peer returned by useAwarenessPeers().
+ * Same as AwarenessUser but with computed idle status.
+ */
+export interface AwarenessPeer extends AwarenessUser {
+    /** True when the peer has not sent an awareness update in 45+ seconds */
+    idle: boolean;
+}
+export interface SpaceMeta {
+    id: string;
+    doc_id: string;
+    name: string;
+    description: string | null;
+    visibility: 'public' | 'private' | 'invite';
+    is_hub: boolean;
+    owner_id: string | null;
+    created_at: number;
+    updated_at: number;
+}
+export interface SavedServer {
+    url: string;
+    label: string;
+    entryDocId?: string;
+    spacesEnabled?: boolean;
+    cachedSpaces?: SpaceMeta[];
+    hubDocId?: string;
+}
+export interface ServerInfo {
+    name?: string;
+    version?: string;
+    index_doc_id?: string;
+}
+export interface LogEntry {
+    time: string;
+    message: string;
+    type: 'system' | 'connection' | 'auth' | 'sync' | 'user' | 'data';
+}
+export declare const UI_COLORS: readonly ["red", "orange", "amber", "yellow", "lime", "green", "emerald", "teal", "cyan", "sky", "blue", "indigo", "violet", "purple", "fuchsia", "pink", "rose", "grass", "diamond", "gold", "redstone", "lapis", "wood", "discord", "steam", "oxidized"];
+export declare const UI_NEUTRALS: readonly ["slate", "gray", "zinc", "neutral", "stone", "cobblestone", "bedrock", "cream", "sage", "lavender", "blush", "copper", "oxidized", "mint", "peach", "mist", "mauve"];
+export declare const COLOR_HUES: Record<string, number>;
+export declare function deriveColorFromPubKey(pubKey: string): {
+    name: string;
+    hsl: string;
+    neutralName: string;
+};
+/** Injected into nuxtApp as $abracadabra */
+export interface AbracadabraState {
+    doc: ShallowRef<Y.Doc>;
+    provider: ShallowRef<any | null>;
+    client: ShallowRef<any | null>;
+    keystore: ShallowRef<any | null>;
+    status: Ref<'disconnected' | 'connecting' | 'connected'>;
+    synced: Ref<boolean>;
+    isReady: Ref<boolean>;
+    logs: Ref<LogEntry[]>;
+    userName: Ref<string>;
+    userColor: Ref<string>;
+    userColorName: Ref<string>;
+    userNeutralColorName: Ref<string>;
+    userCount: Ref<number>;
+    publicKeyB64: Ref<string>;
+    connectionError: Ref<string | null>;
+    isClaimed: Ref<boolean>;
+    identityLost: Ref<boolean>;
+    needsReauth: Ref<boolean>;
+    requirePasskeyOnLogin: Ref<boolean>;
+    isConnectionBlocked: Ref<boolean>;
+    currentServerUrl: Ref<string>;
+    savedServers: Ref<SavedServer[]>;
+    currentServerSpaces: any;
+    currentServerSpacesEnabled: any;
+    pendingInviteCode: Ref<string | null>;
+    registry: import('./plugin-registry').PluginRegistry;
+    addLog: (message: string, type?: LogEntry['type']) => void;
+    setUserName: (name: string) => void;
+    setUserColor: (colorName: string) => void;
+    setNeutralColor: (colorName: string) => void;
+    setRequirePasskey: (enabled: boolean) => void;
+    claimAccount: () => Promise<boolean | undefined>;
+    loginWithHardware: (credentialIdHint?: string) => Promise<boolean>;
+    logout: () => Promise<void>;
+    reconnect: () => void;
+    addServer: (url: string) => Promise<void>;
+    removeServer: (url: string) => void;
+    switchServer: (url: string) => Promise<void>;
+    switchSpace: (serverUrl: string, spaceDocId: string) => Promise<void>;
+    refreshSpaces: () => Promise<void>;
+    createSpace: (opts: {
+        name: string;
+        description?: string;
+        visibility?: SpaceMeta['visibility'];
+        id?: string;
+    }) => Promise<SpaceMeta>;
+    updateSpace: (id: string, opts: Partial<Pick<SpaceMeta, 'name' | 'description' | 'visibility' | 'is_hub'>>) => Promise<SpaceMeta>;
+    deleteSpace: (id: string) => Promise<void>;
+    redeemInvite: (code: string) => Promise<void>;
+    createInvite: (opts?: {
+        role?: string;
+        maxUses?: number;
+        expiresIn?: number;
+    }) => Promise<any>;
+    listInvites: () => Promise<any[]>;
+    revokeInvite: (code: string) => Promise<void>;
+    init: (serverUrl?: string) => Promise<void>;
+}
+/**
+ * Cleanup function returned by a runner's start().
+ * Called on graceful server shutdown.
+ */
+export type RunnerCleanup = (() => void | Promise<void>) | void;
+/**
+ * Context provided to every server-side runner.
+ * Available after the service provider successfully syncs with the root document.
+ */
+export interface ServerRunnerContext {
+    /** Service-role REST + auth client (AbracadabraClient) */
+    client: any;
+    /** Shared HocuspocusProviderWebsocket — reuse for all child providers */
+    wsp: any;
+    /** Root Y.Doc (the world document) */
+    rootDoc: any;
+    /** Root AbracadabraProvider — call .loadChild(docId) to open sub-documents */
+    rootProvider: any;
+    /** Nitro useStorage() handle — use for persistent cache across requests */
+    storage: any;
+    /** Document cache API: read/write HTML+JSON renders, build tree snapshots */
+    docCache: DocCacheAPI;
+}
+/**
+ * A named background task that runs inside the Nitro server process.
+ * start() is called once after the root doc syncs; returns a cleanup function.
+ */
+export interface ServerRunnerDefinition {
+    name: string;
+    start: (ctx: ServerRunnerContext) => Promise<RunnerCleanup>;
+}
+/**
+ * API surface for reading/writing cached document renders.
+ * Backed by Nitro storage (disk or memory depending on server config).
+ */
+export interface DocCacheAPI {
+    getHTML: (docId: string) => Promise<string | null>;
+    getJSON: (docId: string) => Promise<any | null>;
+    invalidate: (docId: string) => Promise<void>;
+    getTree: () => Promise<CachedTreeNode[]>;
+}
+/** A fully rendered and cached document node (used for SSR tree traversal) */
+export interface CachedTreeNode {
+    id: string;
+    label: string;
+    type: string;
+    html: string | null;
+    data: any | null;
+    children: CachedTreeNode[];
+}

package/dist/runtime/types.js

@@ -0,0 +1,93 @@
+export const UI_COLORS = [
+  "red",
+  "orange",
+  "amber",
+  "yellow",
+  "lime",
+  "green",
+  "emerald",
+  "teal",
+  "cyan",
+  "sky",
+  "blue",
+  "indigo",
+  "violet",
+  "purple",
+  "fuchsia",
+  "pink",
+  "rose",
+  "grass",
+  "diamond",
+  "gold",
+  "redstone",
+  "lapis",
+  "wood",
+  "discord",
+  "steam",
+  "oxidized"
+];
+export const UI_NEUTRALS = [
+  "slate",
+  "gray",
+  "zinc",
+  "neutral",
+  "stone",
+  "cobblestone",
+  "bedrock",
+  "cream",
+  "sage",
+  "lavender",
+  "blush",
+  "copper",
+  "oxidized",
+  "mint",
+  "peach",
+  "mist",
+  "mauve"
+];
+export const COLOR_HUES = {
+  red: 0,
+  orange: 24,
+  amber: 38,
+  yellow: 48,
+  lime: 84,
+  green: 142,
+  emerald: 160,
+  teal: 173,
+  cyan: 189,
+  sky: 199,
+  blue: 217,
+  indigo: 239,
+  violet: 258,
+  purple: 271,
+  fuchsia: 292,
+  pink: 330,
+  rose: 350,
+  grass: 142,
+  diamond: 187,
+  gold: 48,
+  redstone: 0,
+  lapis: 217,
+  wood: 20,
+  discord: 235,
+  steam: 84,
+  oxidized: 168
+};
+export function deriveColorFromPubKey(pubKey) {
+  let hash = 0;
+  for (let i = 0; i < pubKey.length; i++) {
+    hash = (hash << 5) - hash + pubKey.charCodeAt(i);
+    hash |= 0;
+  }
+  const index = Math.abs(hash) % UI_COLORS.length;
+  const name = UI_COLORS[index] || "blue";
+  const h = COLOR_HUES[name] || 0;
+  let hash2 = hash ^ 2654435769;
+  for (let i = pubKey.length - 1; i >= 0; i--) {
+    hash2 = (hash2 << 5) - hash2 + pubKey.charCodeAt(i);
+    hash2 |= 0;
+  }
+  const neutralIndex = Math.abs(hash2) % UI_NEUTRALS.length;
+  const neutralName = UI_NEUTRALS[neutralIndex] || "zinc";
+  return { name, hsl: `hsl(${h}, 70%, 75%)`, neutralName };
+}

package/dist/runtime/utils/VoiceClient.d.ts

@@ -0,0 +1,94 @@
+import type { VoiceError } from './voiceErrors.js';
+export type VoiceConnectionStatus = 'idle' | 'connecting' | 'connected' | 'disconnected';
+export interface VoicePeer {
+    id: string;
+    userId: string;
+    stream: MediaStream | null;
+    videoStream: MediaStream | null;
+    screenStream: MediaStream | null;
+    remoteMuted: boolean;
+    localMuted: boolean;
+    audioLevel: number;
+    remoteVideo: boolean;
+    remoteScreen: boolean;
+    displayName: string | null;
+    color: string | null;
+}
+interface VoiceClientEvents {
+    statusChange: (status: VoiceConnectionStatus) => void;
+    peerJoined: (peer: VoicePeer) => void;
+    peerLeft: (peerId: string) => void;
+    peerStream: (peer: VoicePeer) => void;
+    audioLevel: (peerId: string, level: number) => void;
+    localAudioLevel: (level: number) => void;
+    mute: (isMuted: boolean) => void;
+    remoteMute: (peerId: string, muted: boolean) => void;
+    videoChange: (enabled: boolean) => void;
+    screenChange: (enabled: boolean) => void;
+    peerVideoStream: (peerId: string, stream: MediaStream | null, kind: 'camera' | 'screen') => void;
+    peerMediaState: (peerId: string, video: boolean, screen: boolean) => void;
+    peerProfile: (peerId: string, name: string, color: string) => void;
+    error: (err: VoiceError) => void;
+}
+export declare class VoiceClient {
+    private readonly url;
+    private ws;
+    private audioCtx;
+    private _masterVolume;
+    private localStream;
+    private _localVideoStream;
+    private _localScreenStream;
+    private localAudioTimer;
+    private peerConnections;
+    private peerAudio;
+    readonly peers: Map<string, VoicePeer>;
+    private emitter;
+    private myPeerId;
+    private _muted;
+    private _videoEnabled;
+    private _screenEnabled;
+    private _profile;
+    private _status;
+    /** Serialises async message handling so messages never run concurrently. */
+    private _msgQueue;
+    constructor(url: string);
+    on<E extends keyof VoiceClientEvents>(event: E, handler: VoiceClientEvents[E]): import("nanoevents").Unsubscribe;
+    get status(): VoiceConnectionStatus;
+    get isMuted(): boolean;
+    get videoEnabled(): boolean;
+    get screenEnabled(): boolean;
+    get localVideoStream(): MediaStream | null;
+    get localScreenStream(): MediaStream | null;
+    private setStatus;
+    private send;
+    connect(): Promise<void>;
+    private handleMessage;
+    private addPeer;
+    private removePeer;
+    private wirePcEvents;
+    private closePeerConnection;
+    /**
+     * Create a new PC as the offerer — pre-creates the 3-transceiver layout
+     * (audio, camera video, screen video) so the offer SDP defines the m-line order.
+     */
+    private createPeerConnectionForOffer;
+    /**
+     * Create a new PC as the answerer — does NOT pre-create transceivers.
+     * `setRemoteDescription(offer)` will create them to match the offer's m-lines.
+     */
+    private createPeerConnectionForAnswer;
+    private attachLocalTracksToAnswer;
+    private setupPeerAudio;
+    private initiateOffer;
+    private handleOffer;
+    private renegotiateAll;
+    toggleMute(): Promise<void>;
+    toggleVideo(): Promise<void>;
+    toggleScreen(): Promise<void>;
+    setProfile(name: string, color: string): void;
+    togglePeerMute(peerId: string): void;
+    setPeerVolume(peerId: string, volume: number): void;
+    setMasterVolume(volume: number): void;
+    disconnect(): void;
+}
+export {};