@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/crdt/awareness.js

@@ -0,0 +1,109 @@
+/**
+ * Awareness protocol for cursor and selection sync
+ */
+import { Awareness } from 'y-protocols/awareness';
+/**
+ * Create an awareness protocol instance
+ */
+export function createAwarenessProtocol(doc) {
+    const awareness = new Awareness(doc);
+    const userChangeCallbacks = new Set();
+    // Track awareness changes
+    awareness.on('change', () => {
+        const users = getUsers();
+        userChangeCallbacks.forEach((cb) => cb(users));
+    });
+    function getLocalState() {
+        return awareness.getLocalState();
+    }
+    function setLocalState(updates) {
+        const current = getLocalState();
+        awareness.setLocalState({
+            ...current,
+            ...updates
+        });
+    }
+    function getUsers() {
+        const states = awareness.getStates();
+        const users = [];
+        states.forEach((state) => {
+            if (state.user) {
+                users.push(state.user);
+            }
+        });
+        return users;
+    }
+    function getCursors() {
+        const states = awareness.getStates();
+        const cursors = new Map();
+        states.forEach((state, clientId) => {
+            if (state.user && state.cursor) {
+                cursors.set(clientId, {
+                    user: state.user,
+                    cursor: state.cursor
+                });
+            }
+        });
+        return cursors;
+    }
+    return {
+        awareness,
+        setUser(user) {
+            setLocalState({ user, state: 'active' });
+        },
+        setCursor(anchor, head) {
+            setLocalState({ cursor: { anchor, head } });
+        },
+        setSelection(anchor, head) {
+            setLocalState({ selection: { anchor, head } });
+        },
+        setViewingFile(path) {
+            setLocalState({ viewingFile: path });
+        },
+        setEditingFile(path) {
+            setLocalState({ editingFile: path });
+        },
+        setState(state) {
+            setLocalState({ state });
+        },
+        getUsers,
+        getCursors,
+        onUsersChange(callback) {
+            userChangeCallbacks.add(callback);
+            // Immediately call with current users
+            callback(getUsers());
+            return () => userChangeCallbacks.delete(callback);
+        },
+        destroy() {
+            awareness.destroy();
+            userChangeCallbacks.clear();
+        }
+    };
+}
+/**
+ * Generate a random color for a user
+ */
+export function generateUserColor() {
+    const colors = [
+        '#60a5fa', // blue
+        '#a78bfa', // purple
+        '#4ade80', // green
+        '#f472b6', // pink
+        '#facc15', // yellow
+        '#fb923c', // orange
+        '#22d3ee', // cyan
+        '#e879f9' // fuchsia
+    ];
+    return colors[Math.floor(Math.random() * colors.length)];
+}
+/**
+ * Generate initials from a name
+ */
+export function getInitials(name) {
+    return name
+        .split(' ')
+        .map((part) => part[0])
+        .join('')
+        .toUpperCase()
+        .slice(0, 2);
+}

package/dist/crdt/document.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Collaborative Document using Yjs
+ * Provides a wrapper around Yjs Doc for IDE integration
+ */
+import * as Y from 'yjs';
+import type { DocumentOptions } from './types';
+export declare class CollaborativeDocument {
+    readonly doc: Y.Doc;
+    readonly id: string;
+    private texts;
+    private undoManager;
+    constructor(options: DocumentOptions);
+    /**
+     * Get or create a Y.Text for a given key
+     */
+    getText(key?: string): Y.Text;
+    /**
+     * Get the content as a string
+     */
+    getContent(key?: string): string;
+    /**
+     * Set the entire content (replaces existing)
+     */
+    setContent(content: string, key?: string): void;
+    /**
+     * Insert text at position
+     */
+    insert(index: number, content: string, key?: string): void;
+    /**
+     * Delete text at position
+     */
+    delete(index: number, length: number, key?: string): void;
+    /**
+     * Apply a delta (for CodeMirror integration)
+     */
+    applyDelta(changes: Array<{
+        from: number;
+        to: number;
+        insert: string;
+    }>, key?: string): void;
+    /**
+     * Subscribe to text changes
+     */
+    onTextChange(callback: (event: Y.YTextEvent, transaction: Y.Transaction) => void, key?: string): () => void;
+    /**
+     * Subscribe to any document updates
+     */
+    onUpdate(callback: (update: Uint8Array, origin: unknown) => void): () => void;
+    /**
+     * Setup undo manager
+     */
+    private setupUndoManager;
+    /**
+     * Track additional origins for undo
+     */
+    trackOrigin(origin: string): void;
+    /**
+     * Undo last change
+     */
+    undo(): boolean;
+    /**
+     * Redo last undone change
+     */
+    redo(): boolean;
+    /**
+     * Check if can undo
+     */
+    canUndo(): boolean;
+    /**
+     * Check if can redo
+     */
+    canRedo(): boolean;
+    /**
+     * Clear undo/redo history
+     */
+    clearHistory(): void;
+    /**
+     * Create a snapshot of the current state
+     */
+    createSnapshot(): Uint8Array;
+    /**
+     * Apply a snapshot
+     */
+    applySnapshot(snapshot: Uint8Array): void;
+    /**
+     * Get the state vector for sync
+     */
+    getStateVector(): Uint8Array;
+    /**
+     * Get diff from a state vector
+     */
+    getDiff(stateVector: Uint8Array): Uint8Array;
+    /**
+     * Merge updates from another document
+     */
+    merge(update: Uint8Array): void;
+    /**
+     * Destroy the document
+     */
+    destroy(): void;
+}

package/dist/crdt/document.js

@@ -0,0 +1,187 @@
+/**
+ * Collaborative Document using Yjs
+ * Provides a wrapper around Yjs Doc for IDE integration
+ */
+import * as Y from 'yjs';
+export class CollaborativeDocument {
+    doc;
+    id;
+    texts = new Map();
+    undoManager = null;
+    constructor(options) {
+        this.id = options.documentId;
+        this.doc = new Y.Doc();
+        // Create initial text if provided
+        if (options.initialContent !== undefined) {
+            const text = this.getText('content');
+            text.insert(0, options.initialContent);
+        }
+        // Setup undo manager if enabled
+        if (options.enableUndo !== false) {
+            this.setupUndoManager(options.undoCaptureTimeout);
+        }
+    }
+    /**
+     * Get or create a Y.Text for a given key
+     */
+    getText(key = 'content') {
+        let text = this.texts.get(key);
+        if (!text) {
+            text = this.doc.getText(key);
+            this.texts.set(key, text);
+        }
+        return text;
+    }
+    /**
+     * Get the content as a string
+     */
+    getContent(key = 'content') {
+        return this.getText(key).toString();
+    }
+    /**
+     * Set the entire content (replaces existing)
+     */
+    setContent(content, key = 'content') {
+        const text = this.getText(key);
+        this.doc.transact(() => {
+            text.delete(0, text.length);
+            text.insert(0, content);
+        });
+    }
+    /**
+     * Insert text at position
+     */
+    insert(index, content, key = 'content') {
+        this.getText(key).insert(index, content);
+    }
+    /**
+     * Delete text at position
+     */
+    delete(index, length, key = 'content') {
+        this.getText(key).delete(index, length);
+    }
+    /**
+     * Apply a delta (for CodeMirror integration)
+     */
+    applyDelta(changes, key = 'content') {
+        const text = this.getText(key);
+        this.doc.transact(() => {
+            // Apply changes in reverse order to maintain correct positions
+            const sortedChanges = [...changes].sort((a, b) => b.from - a.from);
+            for (const change of sortedChanges) {
+                const deleteLen = change.to - change.from;
+                if (deleteLen > 0) {
+                    text.delete(change.from, deleteLen);
+                }
+                if (change.insert) {
+                    text.insert(change.from, change.insert);
+                }
+            }
+        });
+    }
+    /**
+     * Subscribe to text changes
+     */
+    onTextChange(callback, key = 'content') {
+        const text = this.getText(key);
+        text.observe(callback);
+        return () => text.unobserve(callback);
+    }
+    /**
+     * Subscribe to any document updates
+     */
+    onUpdate(callback) {
+        this.doc.on('update', callback);
+        return () => this.doc.off('update', callback);
+    }
+    /**
+     * Setup undo manager
+     */
+    setupUndoManager(captureTimeout = 500) {
+        const trackedOrigins = new Set([null, 'local']);
+        this.undoManager = new Y.UndoManager(this.getText(), {
+            trackedOrigins,
+            captureTimeout
+        });
+    }
+    /**
+     * Track additional origins for undo
+     */
+    trackOrigin(origin) {
+        if (this.undoManager) {
+            this.undoManager.trackedOrigins.add(origin);
+        }
+    }
+    /**
+     * Undo last change
+     */
+    undo() {
+        if (!this.undoManager)
+            return false;
+        return this.undoManager.undo() !== null;
+    }
+    /**
+     * Redo last undone change
+     */
+    redo() {
+        if (!this.undoManager)
+            return false;
+        return this.undoManager.redo() !== null;
+    }
+    /**
+     * Check if can undo
+     */
+    canUndo() {
+        return this.undoManager?.canUndo() ?? false;
+    }
+    /**
+     * Check if can redo
+     */
+    canRedo() {
+        return this.undoManager?.canRedo() ?? false;
+    }
+    /**
+     * Clear undo/redo history
+     */
+    clearHistory() {
+        this.undoManager?.clear();
+    }
+    /**
+     * Create a snapshot of the current state
+     */
+    createSnapshot() {
+        return Y.encodeStateAsUpdate(this.doc);
+    }
+    /**
+     * Apply a snapshot
+     */
+    applySnapshot(snapshot) {
+        Y.applyUpdate(this.doc, snapshot);
+    }
+    /**
+     * Get the state vector for sync
+     */
+    getStateVector() {
+        return Y.encodeStateVector(this.doc);
+    }
+    /**
+     * Get diff from a state vector
+     */
+    getDiff(stateVector) {
+        return Y.encodeStateAsUpdate(this.doc, stateVector);
+    }
+    /**
+     * Merge updates from another document
+     */
+    merge(update) {
+        Y.applyUpdate(this.doc, update);
+    }
+    /**
+     * Destroy the document
+     */
+    destroy() {
+        this.undoManager?.destroy();
+        this.doc.destroy();
+        this.texts.clear();
+    }
+}

package/dist/crdt/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CRDT module for collaborative editing
+ * Uses Yjs for conflict-free replicated data types
+ */
+export { CollaborativeDocument } from './document';
+export { CollaborativeProvider } from './provider';
+export { createAwarenessProtocol } from './awareness';
+export { createUndoManager } from './undo';
+export type * from './types';

package/dist/crdt/index.js

@@ -0,0 +1,8 @@
+/**
+ * CRDT module for collaborative editing
+ * Uses Yjs for conflict-free replicated data types
+ */
+export { CollaborativeDocument } from './document';
+export { CollaborativeProvider } from './provider';
+export { createAwarenessProtocol } from './awareness';
+export { createUndoManager } from './undo';

package/dist/crdt/provider.d.ts

@@ -0,0 +1,85 @@
+/**
+ * WebSocket provider for Yjs collaboration
+ * Handles connection, sync, and reconnection
+ */
+import { WebsocketProvider } from 'y-websocket';
+import type { Doc as YDoc } from 'yjs';
+import { Awareness } from 'y-protocols/awareness';
+import type { ProviderOptions, ConnectionStatus, AwarenessState } from './types';
+export declare class CollaborativeProvider {
+    readonly provider: WebsocketProvider;
+    readonly awareness: Awareness;
+    private statusListeners;
+    private syncListeners;
+    constructor(options: ProviderOptions);
+    private setupEventListeners;
+    /**
+     * Get current connection status
+     */
+    get status(): ConnectionStatus;
+    /**
+     * Check if synced with server
+     */
+    get synced(): boolean;
+    /**
+     * Connect to the server
+     */
+    connect(): void;
+    /**
+     * Disconnect from the server
+     */
+    disconnect(): void;
+    /**
+     * Set local awareness state
+     */
+    setLocalState(state: Partial<AwarenessState>): void;
+    /**
+     * Get local awareness state
+     */
+    getLocalState(): AwarenessState | null;
+    /**
+     * Get all awareness states
+     */
+    getStates(): Map<number, AwarenessState>;
+    /**
+     * Get awareness state for a specific client
+     */
+    getState(clientId: number): AwarenessState | undefined;
+    /**
+     * Subscribe to connection status changes
+     */
+    onStatus(callback: (status: ConnectionStatus) => void): () => void;
+    /**
+     * Subscribe to sync state changes
+     */
+    onSync(callback: (synced: boolean) => void): () => void;
+    /**
+     * Subscribe to awareness changes
+     */
+    onAwarenessChange(callback: (changes: {
+        added: number[];
+        updated: number[];
+        removed: number[];
+    }, origin: string) => void): () => void;
+    /**
+     * Get all connected client IDs
+     */
+    getClientIds(): number[];
+    /**
+     * Get the local client ID
+     */
+    get clientId(): number;
+    /**
+     * Destroy the provider
+     */
+    destroy(): void;
+}
+/**
+ * Create a provider with sensible defaults for IDE usage
+ */
+export declare function createProvider(doc: YDoc, serverUrl: string, roomId: string, user: {
+    id: string;
+    name: string;
+    color: string;
+    isAI?: boolean;
+}): CollaborativeProvider;

package/dist/crdt/provider.js

@@ -0,0 +1,150 @@
+/**
+ * WebSocket provider for Yjs collaboration
+ * Handles connection, sync, and reconnection
+ */
+import { WebsocketProvider } from 'y-websocket';
+import { Awareness } from 'y-protocols/awareness';
+export class CollaborativeProvider {
+    provider;
+    awareness;
+    statusListeners = new Set();
+    syncListeners = new Set();
+    constructor(options) {
+        // Create awareness if not provided
+        this.awareness = options.awareness ?? new Awareness(options.doc);
+        // Create WebSocket provider
+        this.provider = new WebsocketProvider(options.serverUrl, options.roomId, options.doc, {
+            awareness: this.awareness,
+            params: options.params,
+            connect: options.connect ?? true,
+            resyncInterval: options.resyncInterval ?? 30000,
+            maxBackoffTime: options.maxBackoffTime ?? 10000
+        });
+        // Setup event forwarding
+        this.setupEventListeners();
+    }
+    setupEventListeners() {
+        this.provider.on('status', ({ status }) => {
+            const mappedStatus = status;
+            this.statusListeners.forEach((listener) => listener(mappedStatus));
+        });
+        this.provider.on('sync', (synced) => {
+            this.syncListeners.forEach((listener) => listener(synced));
+        });
+    }
+    /**
+     * Get current connection status
+     */
+    get status() {
+        if (this.provider.wsconnected)
+            return 'connected';
+        if (this.provider.wsconnecting)
+            return 'connecting';
+        return 'disconnected';
+    }
+    /**
+     * Check if synced with server
+     */
+    get synced() {
+        return this.provider.synced;
+    }
+    /**
+     * Connect to the server
+     */
+    connect() {
+        this.provider.connect();
+    }
+    /**
+     * Disconnect from the server
+     */
+    disconnect() {
+        this.provider.disconnect();
+    }
+    /**
+     * Set local awareness state
+     */
+    setLocalState(state) {
+        const currentState = this.awareness.getLocalState();
+        this.awareness.setLocalState({
+            ...currentState,
+            ...state
+        });
+    }
+    /**
+     * Get local awareness state
+     */
+    getLocalState() {
+        return this.awareness.getLocalState();
+    }
+    /**
+     * Get all awareness states
+     */
+    getStates() {
+        return this.awareness.getStates();
+    }
+    /**
+     * Get awareness state for a specific client
+     */
+    getState(clientId) {
+        return this.getStates().get(clientId);
+    }
+    /**
+     * Subscribe to connection status changes
+     */
+    onStatus(callback) {
+        this.statusListeners.add(callback);
+        return () => this.statusListeners.delete(callback);
+    }
+    /**
+     * Subscribe to sync state changes
+     */
+    onSync(callback) {
+        this.syncListeners.add(callback);
+        return () => this.syncListeners.delete(callback);
+    }
+    /**
+     * Subscribe to awareness changes
+     */
+    onAwarenessChange(callback) {
+        this.awareness.on('change', callback);
+        return () => this.awareness.off('change', callback);
+    }
+    /**
+     * Get all connected client IDs
+     */
+    getClientIds() {
+        return Array.from(this.getStates().keys());
+    }
+    /**
+     * Get the local client ID
+     */
+    get clientId() {
+        return this.awareness.clientID;
+    }
+    /**
+     * Destroy the provider
+     */
+    destroy() {
+        this.provider.destroy();
+        this.awareness.destroy();
+        this.statusListeners.clear();
+        this.syncListeners.clear();
+    }
+}
+/**
+ * Create a provider with sensible defaults for IDE usage
+ */
+export function createProvider(doc, serverUrl, roomId, user) {
+    const provider = new CollaborativeProvider({
+        serverUrl,
+        roomId,
+        doc,
+        connect: true
+    });
+    // Set initial awareness state
+    provider.setLocalState({
+        user,
+        state: 'active'
+    });
+    return provider;
+}

package/dist/crdt/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * CRDT-specific types for the collaboration module
+ */
+import type { Doc as YDoc } from 'yjs';
+import type { Awareness } from 'y-protocols/awareness';
+export interface DocumentOptions {
+    documentId: string;
+    initialContent?: string;
+    enableUndo?: boolean;
+    undoCaptureTimeout?: number;
+}
+export interface ProviderOptions {
+    serverUrl: string;
+    roomId: string;
+    doc: YDoc;
+    awareness?: Awareness;
+    params?: Record<string, string>;
+    connect?: boolean;
+    resyncInterval?: number;
+    maxBackoffTime?: number;
+}
+export interface AwarenessState {
+    user: {
+        id: string;
+        name: string;
+        color: string;
+        isAI?: boolean;
+    };
+    cursor?: {
+        anchor: number;
+        head: number;
+    };
+    selection?: {
+        anchor: number;
+        head: number;
+    };
+    viewingFile?: string;
+    editingFile?: string;
+    state: 'active' | 'idle' | 'away';
+}
+export interface CRDTChange {
+    origin: string | null;
+    local: boolean;
+    added: Set<number>;
+    updated: Set<number>;
+    removed: Set<number>;
+}
+export interface SyncState {
+    synced: boolean;
+    pending: number;
+}
+export type ConnectionStatus = 'connecting' | 'connected' | 'disconnected';
+export interface CRDTEventMap {
+    sync: (synced: boolean) => void;
+    update: (update: Uint8Array, origin: string | null) => void;
+    'awareness-change': (changes: CRDTChange) => void;
+    status: (status: {
+        status: ConnectionStatus;
+    }) => void;
+    error: (error: Error) => void;
+}