@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/components/editor/core/git-blame.js

@@ -0,0 +1,324 @@
+/**
+ * Git Blame Manager
+ *
+ * Provides inline git blame information for the editor.
+ * Shows commit info, author, and timestamps per line.
+ */
+const DEFAULT_CONFIG = {
+    colorMode: 'age',
+    showAuthor: true,
+    showTimestamp: true,
+    dateFormat: 'relative',
+    authorColors: [
+        '#22c55e', // green
+        '#3b82f6', // blue
+        '#f59e0b', // amber
+        '#ec4899', // pink
+        '#8b5cf6', // violet
+        '#14b8a6', // teal
+        '#f97316', // orange
+        '#6366f1', // indigo
+        '#ef4444', // red
+        '#84cc16' // lime
+    ],
+    ageColors: ['#22c55e', '#6b7280'] // green (new) to gray (old)
+};
+/**
+ * Git Blame Manager
+ */
+export class GitBlameManager {
+    config;
+    state;
+    listeners = new Set();
+    authorColorMap = new Map();
+    colorIndex = 0;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.state = {
+            enabled: false,
+            lineBlame: new Map(),
+            loading: false,
+            error: null,
+            lastUpdated: null
+        };
+    }
+    /**
+     * Enable blame display
+     */
+    enable() {
+        this.state.enabled = true;
+        this.notify();
+    }
+    /**
+     * Disable blame display
+     */
+    disable() {
+        this.state.enabled = false;
+        this.notify();
+    }
+    /**
+     * Toggle blame display
+     */
+    toggle() {
+        this.state.enabled = !this.state.enabled;
+        this.notify();
+        return this.state.enabled;
+    }
+    /**
+     * Check if blame is enabled
+     */
+    isEnabled() {
+        return this.state.enabled;
+    }
+    /**
+     * Set blame data for lines
+     * This would typically be called after fetching blame from git
+     */
+    setBlameData(data) {
+        this.state.lineBlame = new Map();
+        this.state.loading = false;
+        this.state.error = null;
+        this.state.lastUpdated = new Date();
+        for (const info of data) {
+            // Assign color based on config
+            if (this.config.colorMode === 'author') {
+                info.color = this.getAuthorColor(info.author);
+            }
+            else {
+                info.color = this.getAgeColor(info.timestamp);
+            }
+            this.state.lineBlame.set(info.line, info);
+        }
+        this.notify();
+    }
+    /**
+     * Set loading state
+     */
+    setLoading(loading) {
+        this.state.loading = loading;
+        if (loading) {
+            this.state.error = null;
+        }
+        this.notify();
+    }
+    /**
+     * Set error state
+     */
+    setError(error) {
+        this.state.error = error;
+        this.state.loading = false;
+        this.notify();
+    }
+    /**
+     * Clear all blame data
+     */
+    clear() {
+        this.state.lineBlame = new Map();
+        this.state.error = null;
+        this.state.lastUpdated = null;
+        this.notify();
+    }
+    /**
+     * Get blame info for a specific line
+     */
+    getLineBlame(line) {
+        return this.state.lineBlame.get(line);
+    }
+    /**
+     * Get all blame info
+     */
+    getAllBlame() {
+        return Array.from(this.state.lineBlame.values());
+    }
+    /**
+     * Get current state
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Get configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update configuration
+     */
+    setConfig(config) {
+        this.config = { ...this.config, ...config };
+        // Recompute colors if mode changed
+        if (config.colorMode) {
+            for (const [line, info] of this.state.lineBlame) {
+                if (this.config.colorMode === 'author') {
+                    info.color = this.getAuthorColor(info.author);
+                }
+                else {
+                    info.color = this.getAgeColor(info.timestamp);
+                }
+            }
+        }
+        this.notify();
+    }
+    /**
+     * Get color for an author
+     */
+    getAuthorColor(author) {
+        if (!this.authorColorMap.has(author)) {
+            const color = this.config.authorColors[this.colorIndex % this.config.authorColors.length];
+            this.authorColorMap.set(author, color);
+            this.colorIndex++;
+        }
+        return this.authorColorMap.get(author);
+    }
+    /**
+     * Get color based on age (newer = greener, older = grayer)
+     */
+    getAgeColor(timestamp) {
+        const now = Date.now();
+        const age = now - timestamp.getTime();
+        // Age ranges in milliseconds
+        const oneDay = 24 * 60 * 60 * 1000;
+        const oneWeek = 7 * oneDay;
+        const oneMonth = 30 * oneDay;
+        const sixMonths = 6 * oneMonth;
+        const oneYear = 365 * oneDay;
+        // Return color based on age
+        if (age < oneDay)
+            return '#22c55e'; // Today - bright green
+        if (age < oneWeek)
+            return '#4ade80'; // This week - green
+        if (age < oneMonth)
+            return '#86efac'; // This month - light green
+        if (age < sixMonths)
+            return '#9ca3af'; // Recent - gray
+        if (age < oneYear)
+            return '#6b7280'; // Old - darker gray
+        return '#4b5563'; // Ancient - darkest gray
+    }
+    /**
+     * Format timestamp for display
+     */
+    formatTimestamp(date) {
+        if (this.config.dateFormat === 'relative') {
+            return this.formatRelativeTime(date);
+        }
+        return date.toLocaleDateString(undefined, {
+            year: 'numeric',
+            month: 'short',
+            day: 'numeric'
+        });
+    }
+    /**
+     * Format relative time (e.g., "2 days ago")
+     */
+    formatRelativeTime(date) {
+        const now = Date.now();
+        const diff = now - date.getTime();
+        const seconds = Math.floor(diff / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        const weeks = Math.floor(days / 7);
+        const months = Math.floor(days / 30);
+        const years = Math.floor(days / 365);
+        if (years > 0)
+            return `${years}y ago`;
+        if (months > 0)
+            return `${months}mo ago`;
+        if (weeks > 0)
+            return `${weeks}w ago`;
+        if (days > 0)
+            return `${days}d ago`;
+        if (hours > 0)
+            return `${hours}h ago`;
+        if (minutes > 0)
+            return `${minutes}m ago`;
+        return 'just now';
+    }
+    /**
+     * Subscribe to state changes
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    /**
+     * Notify listeners
+     */
+    notify() {
+        const state = this.getState();
+        for (const listener of this.listeners) {
+            try {
+                listener(state);
+            }
+            catch (e) {
+                console.error('[GitBlameManager] Listener error:', e);
+            }
+        }
+    }
+}
+/**
+ * Create a git blame manager
+ */
+export function createGitBlameManager(config) {
+    return new GitBlameManager(config);
+}
+/**
+ * Generate mock blame data for testing/demo
+ */
+export function generateMockBlameData(lineCount) {
+    const authors = [
+        { name: 'Alice Chen', email: 'alice@example.com' },
+        { name: 'Bob Smith', email: 'bob@example.com' },
+        { name: 'Carol White', email: 'carol@example.com' },
+        { name: 'David Lee', email: 'david@example.com' }
+    ];
+    const messages = [
+        'Initial commit',
+        'Add feature X',
+        'Fix bug in Y',
+        'Refactor Z module',
+        'Update dependencies',
+        'Improve performance',
+        'Add tests',
+        'Fix typo',
+        'Clean up code',
+        'Add documentation'
+    ];
+    const now = Date.now();
+    const blameData = [];
+    // Generate commits
+    const commits = [];
+    for (let i = 0; i < 10; i++) {
+        const daysAgo = Math.floor(Math.random() * 365);
+        commits.push({
+            sha: Math.random().toString(16).substr(2, 7),
+            author: authors[Math.floor(Math.random() * authors.length)],
+            timestamp: new Date(now - daysAgo * 24 * 60 * 60 * 1000),
+            message: messages[Math.floor(Math.random() * messages.length)]
+        });
+    }
+    // Assign commits to lines (consecutive lines often share commits)
+    let currentCommit = commits[0];
+    let runLength = 0;
+    for (let line = 0; line < lineCount; line++) {
+        // Switch commit occasionally
+        if (runLength > 3 + Math.random() * 10) {
+            currentCommit = commits[Math.floor(Math.random() * commits.length)];
+            runLength = 0;
+        }
+        blameData.push({
+            line,
+            commitSha: currentCommit.sha,
+            fullSha: currentCommit.sha + 'abcdef1234567890',
+            author: currentCommit.author.name,
+            authorEmail: currentCommit.author.email,
+            timestamp: currentCommit.timestamp,
+            message: currentCommit.message,
+            uncommitted: Math.random() < 0.05 // 5% chance of uncommitted line
+        });
+        runLength++;
+    }
+    return blameData;
+}

package/dist/components/editor/core/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Core editor module exports
+ */
+export * from './state';
+export * from './navigation';
+export * from './keybindings';
+export * from './crdt-binding';
+export * from './search';
+export * from './folding';
+export * from './multi-cursor';
+export * from './complexity-analyzer';
+export * from './ai-awareness';
+export * from './ghost-pair';
+export * from './semantic-analyzer';
+export * from './commands';
+export * from './timeline';
+export * from './conflict-predictor';
+export * from './echo-cursor';
+export * from './bracket-healer';
+export * from './git-blame';
+export * from './snippet-manager';
+export * from './quick-actions';
+export * from './diagnostics';
+export * from './breakpoints';
+export type { Position } from './state';
+export type { Diagnostic, Range } from './quick-actions';

package/dist/components/editor/core/index.js

@@ -0,0 +1,24 @@
+/**
+ * Core editor module exports
+ */
+export * from './state';
+export * from './navigation';
+export * from './keybindings';
+export * from './crdt-binding';
+export * from './search';
+export * from './folding';
+export * from './multi-cursor';
+export * from './complexity-analyzer';
+export * from './ai-awareness';
+export * from './ghost-pair';
+export * from './semantic-analyzer';
+export * from './commands';
+export * from './timeline';
+export * from './conflict-predictor';
+export * from './echo-cursor';
+export * from './bracket-healer';
+export * from './git-blame';
+export * from './snippet-manager';
+export * from './quick-actions';
+export * from './diagnostics';
+export * from './breakpoints';

package/dist/components/editor/core/keybindings.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Keyboard handling for the custom editor
+ *
+ * This module provides keybinding management and keyboard event handling.
+ */
+import type { EditorState } from './state';
+import type { Navigation } from './navigation';
+/**
+ * Modifier keys
+ */
+export interface Modifiers {
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+}
+/**
+ * Keybinding definition
+ */
+export interface Keybinding {
+    /** Key name (e.g., 'a', 'Enter', 'ArrowLeft') */
+    key: string;
+    /** Required modifiers */
+    modifiers?: Modifiers;
+    /** Handler function */
+    handler: () => boolean | void;
+    /** Description for help/documentation */
+    description?: string;
+    /** Whether binding works in readonly mode */
+    readonly?: boolean;
+}
+/**
+ * Create default keybindings for the editor
+ */
+export declare function createDefaultKeybindings(state: EditorState, nav: Navigation, options?: {
+    onSave?: () => void;
+    readonly?: boolean;
+    pageSize?: number;
+}): Keybinding[];
+/**
+ * Keyboard handler class
+ */
+export declare class KeyboardHandler {
+    private keybindings;
+    private enabled;
+    /**
+     * Set keybindings
+     */
+    setKeybindings(keybindings: Keybinding[]): void;
+    /**
+     * Add a keybinding
+     */
+    addKeybinding(keybinding: Keybinding): void;
+    /**
+     * Remove a keybinding
+     */
+    removeKeybinding(key: string, modifiers?: Modifiers): void;
+    /**
+     * Enable/disable keyboard handling
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Handle a keyboard event
+     * Returns true if the event was handled
+     */
+    handleKeyDown(e: KeyboardEvent, readonly?: boolean): boolean;
+    /**
+     * Check if modifiers are equal
+     */
+    private modifiersEqual;
+    /**
+     * Get all keybindings for documentation
+     */
+    getKeybindings(): Keybinding[];
+}
+/**
+ * Create keyboard handler
+ */
+export declare function createKeyboardHandler(): KeyboardHandler;