@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/stores/collaboration.svelte.js

@@ -0,0 +1,334 @@
+/**
+ * Collaboration store using Svelte 5 runes
+ * Manages CRDT-based real-time collaboration
+ *
+ * Note: Svelte 5 modules cannot directly export $derived values.
+ * We use getter functions to expose reactive derived state.
+ */
+// Reactive state
+let state = $state({
+    config: null,
+    status: 'disconnected',
+    error: null,
+    synced: false,
+    users: [],
+    cursors: new Map(),
+    awareness: new Map(),
+    aiSessions: [],
+    pendingChanges: [],
+    snapshots: [],
+    localUser: null
+});
+// Event handlers
+const eventHandlers = new Set();
+// Getter functions for derived values (Svelte 5 module-safe)
+export function getConfig() {
+    return state.config;
+}
+export function getStatus() {
+    return state.status;
+}
+export function getError() {
+    return state.error;
+}
+export function getSynced() {
+    return state.synced;
+}
+export function getUsers() {
+    return state.users;
+}
+export function getCursors() {
+    return Array.from(state.cursors.values());
+}
+export function getAwareness() {
+    return Array.from(state.awareness.values());
+}
+export function getAISessions() {
+    return state.aiSessions;
+}
+export function getActiveAISessions() {
+    return state.aiSessions.filter((s) => s.status === 'active');
+}
+export function getPendingChanges() {
+    return state.pendingChanges;
+}
+export function getSnapshots() {
+    return state.snapshots;
+}
+export function getLocalUser() {
+    return state.localUser;
+}
+export function getIsConnected() {
+    return state.status === 'connected';
+}
+export function getOtherUsers() {
+    return state.users.filter((u) => u.id !== state.localUser?.id);
+}
+// Legacy aliases for backward compatibility
+export const config = { get current() { return getConfig(); } };
+export const status = { get current() { return getStatus(); } };
+export const error = { get current() { return getError(); } };
+export const synced = { get current() { return getSynced(); } };
+export const users = { get current() { return getUsers(); } };
+export const cursors = { get current() { return getCursors(); } };
+export const awareness = { get current() { return getAwareness(); } };
+export const aiSessions = { get current() { return getAISessions(); } };
+export const activeAISessions = { get current() { return getActiveAISessions(); } };
+export const pendingChanges = { get current() { return getPendingChanges(); } };
+export const snapshots = { get current() { return getSnapshots(); } };
+export const localUser = { get current() { return getLocalUser(); } };
+export const isConnected = { get current() { return getIsConnected(); } };
+export const otherUsers = { get current() { return getOtherUsers(); } };
+// Collaboration colors for cursors
+const CURSOR_COLORS = [
+    'var(--ide-collab-cursor-1)',
+    'var(--ide-collab-cursor-2)',
+    'var(--ide-collab-cursor-3)',
+    'var(--ide-collab-cursor-4)',
+    'var(--ide-collab-cursor-5)'
+];
+/**
+ * Initialize collaboration with config
+ */
+export function initialize(collabConfig) {
+    state.config = collabConfig;
+    state.localUser = collabConfig.user;
+    state.status = 'connecting';
+}
+/**
+ * Set connection status
+ */
+export function setStatus(newStatus, errorMsg) {
+    state.status = newStatus;
+    state.error = errorMsg ?? null;
+    if (newStatus === 'connected') {
+        emitEvent({ type: 'connected', users: state.users });
+    }
+    else if (newStatus === 'disconnected') {
+        emitEvent({ type: 'disconnected', reason: errorMsg });
+    }
+}
+/**
+ * Set synced state
+ */
+export function setSynced(syncedState) {
+    state.synced = syncedState;
+}
+/**
+ * Add a user to the session
+ */
+export function addUser(user) {
+    // Assign a color if not provided
+    if (!user.color) {
+        const colorIndex = state.users.length % CURSOR_COLORS.length;
+        user = { ...user, color: CURSOR_COLORS[colorIndex] };
+    }
+    if (!state.users.some((u) => u.id === user.id)) {
+        state.users = [...state.users, user];
+        emitEvent({ type: 'user_joined', user });
+    }
+}
+/**
+ * Remove a user from the session
+ */
+export function removeUser(userId) {
+    state.users = state.users.filter((u) => u.id !== userId);
+    state.cursors.delete(userId);
+    state.awareness.delete(userId);
+    emitEvent({ type: 'user_left', userId });
+}
+/**
+ * Update cursor position for a user
+ */
+export function updateCursor(cursor) {
+    state.cursors.set(cursor.userId, cursor);
+    emitEvent({ type: 'cursor_moved', cursor });
+}
+/**
+ * Update awareness for a user
+ */
+export function updateAwareness(awarenessData) {
+    state.awareness.set(awarenessData.userId, awarenessData);
+}
+/**
+ * Update local user's cursor
+ */
+export function setLocalCursor(position, selection) {
+    if (!state.localUser)
+        return;
+    const cursor = {
+        userId: state.localUser.id,
+        user: state.localUser,
+        position,
+        selection,
+        lastActivity: new Date()
+    };
+    state.cursors.set(state.localUser.id, cursor);
+}
+/**
+ * Update local user's awareness
+ */
+export function setLocalAwareness(updates) {
+    if (!state.localUser)
+        return;
+    const current = state.awareness.get(state.localUser.id);
+    const awarenessData = {
+        ...current,
+        userId: state.localUser.id,
+        user: state.localUser,
+        state: 'active',
+        ...updates
+    };
+    state.awareness.set(state.localUser.id, awarenessData);
+}
+/**
+ * Start an AI collaboration session
+ */
+export function startAISession(documentId, aiUser) {
+    const id = crypto.randomUUID();
+    const session = {
+        id,
+        documentId,
+        status: 'pending',
+        aiUser: { ...aiUser, isAI: true, color: 'var(--ide-collab-ai)' },
+        humanUsers: state.users.filter((u) => !u.isAI),
+        startedAt: new Date(),
+        updatedAt: new Date()
+    };
+    state.aiSessions = [...state.aiSessions, session];
+    // Add AI as a user
+    addUser(session.aiUser);
+    emitEvent({ type: 'ai_edit_started', session });
+    return id;
+}
+/**
+ * Update AI session status
+ */
+export function updateAISession(sessionId, updates) {
+    state.aiSessions = state.aiSessions.map((s) => s.id === sessionId ? { ...s, ...updates, updatedAt: new Date() } : s);
+}
+/**
+ * Set current task for AI session
+ */
+export function setAITask(sessionId, task) {
+    updateAISession(sessionId, { currentTask: task, status: 'active' });
+}
+/**
+ * Propose a change from AI
+ */
+export function proposeAIChange(sessionId, change) {
+    const id = crypto.randomUUID();
+    const proposedChange = {
+        ...change,
+        id,
+        sessionId,
+        status: 'pending'
+    };
+    state.pendingChanges = [...state.pendingChanges, proposedChange];
+    emitEvent({ type: 'ai_edit_proposed', change: proposedChange });
+    return id;
+}
+/**
+ * Review an AI proposed change
+ */
+export function reviewAIChange(changeId, approved, reviewerId) {
+    state.pendingChanges = state.pendingChanges.map((c) => c.id === changeId
+        ? {
+            ...c,
+            status: approved ? 'approved' : 'rejected',
+            reviewedBy: reviewerId,
+            reviewedAt: new Date()
+        }
+        : c);
+}
+/**
+ * Complete an AI session
+ */
+export function completeAISession(sessionId) {
+    const session = state.aiSessions.find((s) => s.id === sessionId);
+    if (!session)
+        return;
+    updateAISession(sessionId, { status: 'completed' });
+    // Remove AI user
+    removeUser(session.aiUser.id);
+    // Clear pending changes for this session
+    state.pendingChanges = state.pendingChanges.filter((c) => c.sessionId !== sessionId);
+    emitEvent({ type: 'ai_edit_completed', sessionId });
+}
+/**
+ * Cancel an AI session
+ */
+export function cancelAISession(sessionId) {
+    const session = state.aiSessions.find((s) => s.id === sessionId);
+    if (!session)
+        return;
+    updateAISession(sessionId, { status: 'cancelled' });
+    removeUser(session.aiUser.id);
+    // Reject all pending changes for this session
+    state.pendingChanges = state.pendingChanges.map((c) => c.sessionId === sessionId ? { ...c, status: 'rejected' } : c);
+}
+/**
+ * Create a document snapshot
+ */
+export function createSnapshot(documentId, content, reason = 'manual') {
+    const id = crypto.randomUUID();
+    const snapshot = {
+        id,
+        documentId,
+        content,
+        version: state.snapshots.filter((s) => s.documentId === documentId).length + 1,
+        createdAt: new Date(),
+        createdBy: state.localUser,
+        reason
+    };
+    state.snapshots = [...state.snapshots, snapshot];
+    emitEvent({ type: 'snapshot_created', snapshot });
+    return id;
+}
+/**
+ * Get snapshots for a document
+ */
+export function getDocumentSnapshots(documentId) {
+    return state.snapshots.filter((s) => s.documentId === documentId);
+}
+/**
+ * Subscribe to collaboration events
+ */
+export function onEvent(handler) {
+    eventHandlers.add(handler);
+    return () => eventHandlers.delete(handler);
+}
+/**
+ * Emit a collaboration event
+ */
+function emitEvent(event) {
+    eventHandlers.forEach((handler) => handler(event));
+}
+/**
+ * Disconnect and cleanup
+ */
+export function disconnect() {
+    state.status = 'disconnected';
+    state.users = [];
+    state.cursors.clear();
+    state.awareness.clear();
+    state.synced = false;
+}
+/**
+ * Reset collaboration state
+ */
+export function reset() {
+    disconnect();
+    state.config = null;
+    state.localUser = null;
+    state.aiSessions = [];
+    state.pendingChanges = [];
+    state.snapshots = [];
+    state.error = null;
+}
+/**
+ * Get user color by index
+ */
+export function getUserColor(index) {
+    return CURSOR_COLORS[index % CURSOR_COLORS.length];
+}

package/dist/stores/editor.svelte.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Editor store using Svelte 5 runes
+ * Manages tabs, active file, and editor preferences
+ *
+ * Note: Svelte 5 modules cannot directly export $derived values.
+ * We use getter functions to expose reactive derived state.
+ */
+import type { EditorTab, EditorPreferences, SplitMode, CursorPosition } from '../types';
+export declare function getTabs(): EditorTab[];
+export declare function getActiveTabId(): string | null;
+export declare function getActiveTab(): EditorTab | null;
+export declare function getSplitMode(): SplitMode;
+export declare function getPreferences(): EditorPreferences;
+export declare function getRecentFiles(): string[];
+export declare function getLoading(): boolean;
+export declare function getError(): string | null;
+export declare function getDirtyTabs(): EditorTab[];
+export declare function getHasDirtyTabs(): boolean;
+export declare const tabs: {
+    readonly current: EditorTab[];
+};
+export declare const activeTabId: {
+    readonly current: string | null;
+};
+export declare const activeTab: {
+    readonly current: EditorTab | null;
+};
+export declare const splitMode: {
+    readonly current: SplitMode;
+};
+export declare const preferences: {
+    readonly current: EditorPreferences;
+};
+export declare const recentFiles: {
+    readonly current: string[];
+};
+export declare const loading: {
+    readonly current: boolean;
+};
+export declare const error: {
+    readonly current: string | null;
+};
+export declare const dirtyTabs: {
+    readonly current: EditorTab[];
+};
+export declare const hasDirtyTabs: {
+    readonly current: boolean;
+};
+/**
+ * Open a file in a new tab or focus existing tab
+ */
+export declare function openFile(path: string, content: string, options?: {
+    language?: string;
+    focus?: boolean;
+}): string;
+/**
+ * Close a tab by ID
+ */
+export declare function closeTab(tabId: string): boolean;
+/**
+ * Force close a tab, ignoring dirty state
+ */
+export declare function forceCloseTab(tabId: string): void;
+/**
+ * Close all tabs
+ */
+export declare function closeAllTabs(force?: boolean): boolean;
+/**
+ * Close other tabs (keep the specified one)
+ */
+export declare function closeOtherTabs(keepTabId: string, force?: boolean): boolean;
+/**
+ * Set the active tab
+ */
+export declare function setActiveTab(tabId: string): void;
+/**
+ * Update content for a tab
+ */
+export declare function updateContent(tabId: string, content: string): void;
+/**
+ * Mark a tab as saved
+ */
+export declare function markSaved(tabId: string, newContent?: string): void;
+/**
+ * Update cursor position for a tab
+ */
+export declare function updateCursor(tabId: string, position: CursorPosition): void;
+/**
+ * Mark a tab as being edited by AI
+ */
+export declare function setAIEditing(tabId: string, editing: boolean): void;
+/**
+ * Reorder tabs
+ */
+export declare function reorderTabs(fromIndex: number, toIndex: number): void;
+/**
+ * Set split mode
+ */
+export declare function setSplitMode(mode: SplitMode): void;
+/**
+ * Update editor preferences
+ */
+export declare function updatePreferences(updates: Partial<EditorPreferences>): void;
+/**
+ * Reset preferences to defaults
+ */
+export declare function resetPreferences(): void;
+/**
+ * Get a tab by ID
+ */
+export declare function getTab(tabId: string): EditorTab | undefined;
+/**
+ * Get a tab by path
+ */
+export declare function getTabByPath(path: string): EditorTab | undefined;
+/**
+ * Navigate to next tab
+ */
+export declare function nextTab(): void;
+/**
+ * Navigate to previous tab
+ */
+export declare function prevTab(): void;
+/**
+ * Set loading state
+ */
+export declare function setLoading(loadingState: boolean): void;
+/**
+ * Set error state
+ */
+export declare function setError(errorState: string | null): void;

package/dist/stores/editor.svelte.js

@@ -0,0 +1,250 @@
+/**
+ * Editor store using Svelte 5 runes
+ * Manages tabs, active file, and editor preferences
+ *
+ * Note: Svelte 5 modules cannot directly export $derived values.
+ * We use getter functions to expose reactive derived state.
+ */
+import { DEFAULT_EDITOR_PREFERENCES } from '../types';
+import { detectLanguage } from '../utils/language';
+// Reactive state using $state rune
+let state = $state({
+    tabs: [],
+    activeTabId: null,
+    splitMode: 'none',
+    preferences: { ...DEFAULT_EDITOR_PREFERENCES },
+    recentFiles: [],
+    loading: false,
+    error: null
+});
+// Getter functions for derived values (Svelte 5 module-safe)
+export function getTabs() {
+    return state.tabs;
+}
+export function getActiveTabId() {
+    return state.activeTabId;
+}
+export function getActiveTab() {
+    return state.tabs.find((t) => t.id === state.activeTabId) ?? null;
+}
+export function getSplitMode() {
+    return state.splitMode;
+}
+export function getPreferences() {
+    return state.preferences;
+}
+export function getRecentFiles() {
+    return state.recentFiles;
+}
+export function getLoading() {
+    return state.loading;
+}
+export function getError() {
+    return state.error;
+}
+export function getDirtyTabs() {
+    return state.tabs.filter((t) => t.isDirty);
+}
+export function getHasDirtyTabs() {
+    return state.tabs.some((t) => t.isDirty);
+}
+// Legacy aliases for backward compatibility
+export const tabs = { get current() { return getTabs(); } };
+export const activeTabId = { get current() { return getActiveTabId(); } };
+export const activeTab = { get current() { return getActiveTab(); } };
+export const splitMode = { get current() { return getSplitMode(); } };
+export const preferences = { get current() { return getPreferences(); } };
+export const recentFiles = { get current() { return getRecentFiles(); } };
+export const loading = { get current() { return getLoading(); } };
+export const error = { get current() { return getError(); } };
+export const dirtyTabs = { get current() { return getDirtyTabs(); } };
+export const hasDirtyTabs = { get current() { return getHasDirtyTabs(); } };
+/**
+ * Open a file in a new tab or focus existing tab
+ */
+export function openFile(path, content, options) {
+    const existing = state.tabs.find((t) => t.path === path);
+    if (existing) {
+        if (options?.focus !== false) {
+            state.activeTabId = existing.id;
+        }
+        return existing.id;
+    }
+    const name = path.split('/').pop() ?? path;
+    const language = options?.language ?? detectLanguage(name);
+    const id = crypto.randomUUID();
+    const tab = {
+        id,
+        path,
+        name,
+        content,
+        language,
+        isDirty: false,
+        cursorPosition: { line: 1, column: 1 }
+    };
+    state.tabs = [...state.tabs, tab];
+    if (options?.focus !== false) {
+        state.activeTabId = id;
+    }
+    // Update recent files
+    state.recentFiles = [path, ...state.recentFiles.filter((f) => f !== path)].slice(0, 20);
+    return id;
+}
+/**
+ * Close a tab by ID
+ */
+export function closeTab(tabId) {
+    const index = state.tabs.findIndex((t) => t.id === tabId);
+    if (index === -1)
+        return false;
+    const tab = state.tabs[index];
+    if (tab.isDirty) {
+        // Could prompt for save here - returning false indicates unsaved changes
+        return false;
+    }
+    state.tabs = state.tabs.filter((t) => t.id !== tabId);
+    // Update active tab if we closed the active one
+    if (state.activeTabId === tabId) {
+        const newIndex = Math.min(index, state.tabs.length - 1);
+        state.activeTabId = state.tabs[newIndex]?.id ?? null;
+    }
+    return true;
+}
+/**
+ * Force close a tab, ignoring dirty state
+ */
+export function forceCloseTab(tabId) {
+    const index = state.tabs.findIndex((t) => t.id === tabId);
+    if (index === -1)
+        return;
+    state.tabs = state.tabs.filter((t) => t.id !== tabId);
+    if (state.activeTabId === tabId) {
+        const newIndex = Math.min(index, state.tabs.length - 1);
+        state.activeTabId = state.tabs[newIndex]?.id ?? null;
+    }
+}
+/**
+ * Close all tabs
+ */
+export function closeAllTabs(force = false) {
+    if (!force && state.tabs.some((t) => t.isDirty)) {
+        return false;
+    }
+    state.tabs = [];
+    state.activeTabId = null;
+    return true;
+}
+/**
+ * Close other tabs (keep the specified one)
+ */
+export function closeOtherTabs(keepTabId, force = false) {
+    if (!force && state.tabs.some((t) => t.id !== keepTabId && t.isDirty)) {
+        return false;
+    }
+    state.tabs = state.tabs.filter((t) => t.id === keepTabId);
+    state.activeTabId = keepTabId;
+    return true;
+}
+/**
+ * Set the active tab
+ */
+export function setActiveTab(tabId) {
+    if (state.tabs.some((t) => t.id === tabId)) {
+        state.activeTabId = tabId;
+    }
+}
+/**
+ * Update content for a tab
+ */
+export function updateContent(tabId, content) {
+    state.tabs = state.tabs.map((t) => t.id === tabId ? { ...t, content, isDirty: t.content !== content || t.isDirty } : t);
+}
+/**
+ * Mark a tab as saved
+ */
+export function markSaved(tabId, newContent) {
+    state.tabs = state.tabs.map((t) => t.id === tabId ? { ...t, isDirty: false, content: newContent ?? t.content } : t);
+}
+/**
+ * Update cursor position for a tab
+ */
+export function updateCursor(tabId, position) {
+    state.tabs = state.tabs.map((t) => (t.id === tabId ? { ...t, cursorPosition: position } : t));
+}
+/**
+ * Mark a tab as being edited by AI
+ */
+export function setAIEditing(tabId, editing) {
+    state.tabs = state.tabs.map((t) => (t.id === tabId ? { ...t, aiEditing: editing } : t));
+}
+/**
+ * Reorder tabs
+ */
+export function reorderTabs(fromIndex, toIndex) {
+    const newTabs = [...state.tabs];
+    const [removed] = newTabs.splice(fromIndex, 1);
+    newTabs.splice(toIndex, 0, removed);
+    state.tabs = newTabs;
+}
+/**
+ * Set split mode
+ */
+export function setSplitMode(mode) {
+    state.splitMode = mode;
+}
+/**
+ * Update editor preferences
+ */
+export function updatePreferences(updates) {
+    state.preferences = { ...state.preferences, ...updates };
+}
+/**
+ * Reset preferences to defaults
+ */
+export function resetPreferences() {
+    state.preferences = { ...DEFAULT_EDITOR_PREFERENCES };
+}
+/**
+ * Get a tab by ID
+ */
+export function getTab(tabId) {
+    return state.tabs.find((t) => t.id === tabId);
+}
+/**
+ * Get a tab by path
+ */
+export function getTabByPath(path) {
+    return state.tabs.find((t) => t.path === path);
+}
+/**
+ * Navigate to next tab
+ */
+export function nextTab() {
+    if (state.tabs.length === 0)
+        return;
+    const currentIndex = state.tabs.findIndex((t) => t.id === state.activeTabId);
+    const nextIndex = (currentIndex + 1) % state.tabs.length;
+    state.activeTabId = state.tabs[nextIndex].id;
+}
+/**
+ * Navigate to previous tab
+ */
+export function prevTab() {
+    if (state.tabs.length === 0)
+        return;
+    const currentIndex = state.tabs.findIndex((t) => t.id === state.activeTabId);
+    const prevIndex = (currentIndex - 1 + state.tabs.length) % state.tabs.length;
+    state.activeTabId = state.tabs[prevIndex].id;
+}
+/**
+ * Set loading state
+ */
+export function setLoading(loadingState) {
+    state.loading = loadingState;
+}
+/**
+ * Set error state
+ */
+export function setError(errorState) {
+    state.error = errorState;
+}