@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/utils/format.js

@@ -0,0 +1,152 @@
+/**
+ * Formatting utilities
+ */
+/**
+ * Format file size in human-readable form
+ */
+export function formatFileSize(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const k = 1024;
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${units[i]}`;
+}
+/**
+ * Format a date relative to now
+ */
+export function formatRelativeTime(date) {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffSecs = Math.floor(diffMs / 1000);
+    const diffMins = Math.floor(diffSecs / 60);
+    const diffHours = Math.floor(diffMins / 60);
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffSecs < 60) {
+        return 'just now';
+    }
+    else if (diffMins < 60) {
+        return `${diffMins}m ago`;
+    }
+    else if (diffHours < 24) {
+        return `${diffHours}h ago`;
+    }
+    else if (diffDays < 7) {
+        return `${diffDays}d ago`;
+    }
+    else {
+        return date.toLocaleDateString();
+    }
+}
+/**
+ * Format a date for display
+ */
+export function formatDate(date) {
+    return date.toLocaleDateString(undefined, {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric'
+    });
+}
+/**
+ * Format a date and time for display
+ */
+export function formatDateTime(date) {
+    return date.toLocaleString(undefined, {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit'
+    });
+}
+/**
+ * Format duration in milliseconds to human readable
+ */
+export function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    else if (ms < 60000) {
+        return `${(ms / 1000).toFixed(1)}s`;
+    }
+    else if (ms < 3600000) {
+        return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
+    }
+    else {
+        return `${Math.floor(ms / 3600000)}h ${Math.floor((ms % 3600000) / 60000)}m`;
+    }
+}
+/**
+ * Format line and column position
+ */
+export function formatPosition(line, column) {
+    return `Ln ${line}, Col ${column}`;
+}
+/**
+ * Format a path for display (truncate middle if too long)
+ */
+export function formatPath(path, maxLength = 50) {
+    if (path.length <= maxLength) {
+        return path;
+    }
+    const parts = path.split('/');
+    if (parts.length <= 2) {
+        return path.slice(0, maxLength - 3) + '...';
+    }
+    const first = parts[0];
+    const last = parts[parts.length - 1];
+    const middle = '...';
+    if (first.length + last.length + middle.length >= maxLength) {
+        return '...' + last.slice(-(maxLength - 3));
+    }
+    return `${first}/${middle}/${last}`;
+}
+/**
+ * Format number with thousands separators
+ */
+export function formatNumber(num) {
+    return num.toLocaleString();
+}
+/**
+ * Format percentage
+ */
+export function formatPercent(value, decimals = 0) {
+    return `${(value * 100).toFixed(decimals)}%`;
+}
+/**
+ * Pluralize a word based on count
+ */
+export function pluralize(count, singular, plural) {
+    if (count === 1) {
+        return `${count} ${singular}`;
+    }
+    return `${count} ${plural ?? singular + 's'}`;
+}
+/**
+ * Truncate text with ellipsis
+ */
+export function truncate(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return text.slice(0, maxLength - 1) + '…';
+}
+/**
+ * Convert camelCase to Title Case
+ */
+export function camelToTitle(text) {
+    return text
+        .replace(/([A-Z])/g, ' $1')
+        .replace(/^./, (str) => str.toUpperCase())
+        .trim();
+}
+/**
+ * Convert snake_case to Title Case
+ */
+export function snakeToTitle(text) {
+    return text
+        .split('_')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './language';
+export * from './format';
+export * from './keybindings';

package/dist/utils/index.js

@@ -0,0 +1,4 @@
+// Re-export all utilities
+export * from './language';
+export * from './format';
+export * from './keybindings';

package/dist/utils/keybindings.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Keyboard shortcut utilities
+ */
+export interface Keybinding {
+    keys: string[];
+    command: string;
+    when?: string;
+    label?: string;
+}
+/**
+ * Check if running on macOS
+ */
+export declare function isMac(): boolean;
+/**
+ * Get the modifier key name for the current platform
+ */
+export declare function getModKey(): string;
+/**
+ * Format a key combination for display
+ */
+export declare function formatKeybinding(keys: string[]): string;
+/**
+ * Check if a keyboard event matches a key combination
+ */
+export declare function matchesKeybinding(event: KeyboardEvent, keys: string[]): boolean;
+/**
+ * Create a keyboard event handler for a set of keybindings
+ */
+export declare function createKeybindingHandler(bindings: Keybinding[], executeCommand: (command: string) => void): (event: KeyboardEvent) => void;
+/**
+ * Default IDE keybindings
+ */
+export declare const defaultKeybindings: Keybinding[];

package/dist/utils/keybindings.js

@@ -0,0 +1,171 @@
+/**
+ * Keyboard shortcut utilities
+ */
+/**
+ * Check if running on macOS
+ */
+export function isMac() {
+    if (typeof navigator === 'undefined')
+        return false;
+    return navigator.platform.toUpperCase().indexOf('MAC') >= 0;
+}
+/**
+ * Get the modifier key name for the current platform
+ */
+export function getModKey() {
+    return isMac() ? 'Cmd' : 'Ctrl';
+}
+/**
+ * Format a key combination for display
+ */
+export function formatKeybinding(keys) {
+    return keys
+        .map((key) => {
+        switch (key.toLowerCase()) {
+            case 'mod':
+                return isMac() ? '⌘' : 'Ctrl';
+            case 'ctrl':
+                return isMac() ? '⌃' : 'Ctrl';
+            case 'alt':
+                return isMac() ? '⌥' : 'Alt';
+            case 'shift':
+                return isMac() ? '⇧' : 'Shift';
+            case 'meta':
+            case 'cmd':
+                return '⌘';
+            case 'enter':
+                return '↵';
+            case 'escape':
+            case 'esc':
+                return 'Esc';
+            case 'backspace':
+                return '⌫';
+            case 'delete':
+                return '⌦';
+            case 'tab':
+                return '⇥';
+            case 'space':
+                return 'Space';
+            case 'up':
+                return '↑';
+            case 'down':
+                return '↓';
+            case 'left':
+                return '←';
+            case 'right':
+                return '→';
+            default:
+                return key.toUpperCase();
+        }
+    })
+        .join(isMac() ? '' : '+');
+}
+/**
+ * Check if a keyboard event matches a key combination
+ */
+export function matchesKeybinding(event, keys) {
+    const normalizedKeys = keys.map((k) => k.toLowerCase());
+    // Check modifiers
+    const needsMod = normalizedKeys.includes('mod');
+    const needsCtrl = normalizedKeys.includes('ctrl');
+    const needsAlt = normalizedKeys.includes('alt');
+    const needsShift = normalizedKeys.includes('shift');
+    const needsMeta = normalizedKeys.includes('meta') || normalizedKeys.includes('cmd');
+    // On Mac, 'mod' maps to Meta (Cmd), on others to Ctrl
+    const modKey = isMac() ? event.metaKey : event.ctrlKey;
+    if (needsMod && !modKey)
+        return false;
+    if (needsCtrl && !event.ctrlKey)
+        return false;
+    if (needsAlt && !event.altKey)
+        return false;
+    if (needsShift && !event.shiftKey)
+        return false;
+    if (needsMeta && !event.metaKey)
+        return false;
+    // Check if extra modifiers are pressed
+    const modifiersInBinding = ['mod', 'ctrl', 'alt', 'shift', 'meta', 'cmd'];
+    const hasExtraCtrl = event.ctrlKey && !needsCtrl && !(needsMod && !isMac());
+    const hasExtraAlt = event.altKey && !needsAlt;
+    const hasExtraShift = event.shiftKey && !needsShift;
+    const hasExtraMeta = event.metaKey && !needsMeta && !(needsMod && isMac());
+    if (hasExtraCtrl || hasExtraAlt || hasExtraShift || hasExtraMeta) {
+        return false;
+    }
+    // Get the main key (non-modifier)
+    const mainKey = normalizedKeys.find((k) => !modifiersInBinding.includes(k));
+    if (!mainKey)
+        return false;
+    // Normalize event key
+    let eventKey = event.key.toLowerCase();
+    // Handle special keys
+    if (eventKey === ' ')
+        eventKey = 'space';
+    if (eventKey === 'arrowup')
+        eventKey = 'up';
+    if (eventKey === 'arrowdown')
+        eventKey = 'down';
+    if (eventKey === 'arrowleft')
+        eventKey = 'left';
+    if (eventKey === 'arrowright')
+        eventKey = 'right';
+    return eventKey === mainKey;
+}
+/**
+ * Create a keyboard event handler for a set of keybindings
+ */
+export function createKeybindingHandler(bindings, executeCommand) {
+    return (event) => {
+        for (const binding of bindings) {
+            if (matchesKeybinding(event, binding.keys)) {
+                event.preventDefault();
+                event.stopPropagation();
+                executeCommand(binding.command);
+                return;
+            }
+        }
+    };
+}
+/**
+ * Default IDE keybindings
+ */
+export const defaultKeybindings = [
+    // File operations
+    { keys: ['mod', 's'], command: 'file.save', label: 'Save' },
+    { keys: ['mod', 'shift', 's'], command: 'file.saveAll', label: 'Save All' },
+    { keys: ['mod', 'w'], command: 'file.close', label: 'Close Tab' },
+    { keys: ['mod', 'shift', 'w'], command: 'file.closeAll', label: 'Close All Tabs' },
+    { keys: ['mod', 'n'], command: 'file.new', label: 'New File' },
+    { keys: ['mod', 'o'], command: 'file.open', label: 'Open File' },
+    // Navigation
+    { keys: ['mod', 'p'], command: 'quickOpen', label: 'Quick Open' },
+    { keys: ['mod', 'shift', 'p'], command: 'commandPalette', label: 'Command Palette' },
+    { keys: ['mod', 'g'], command: 'goToLine', label: 'Go to Line' },
+    { keys: ['ctrl', 'tab'], command: 'tab.next', label: 'Next Tab' },
+    { keys: ['ctrl', 'shift', 'tab'], command: 'tab.prev', label: 'Previous Tab' },
+    // Search
+    { keys: ['mod', 'f'], command: 'search.find', label: 'Find' },
+    { keys: ['mod', 'h'], command: 'search.replace', label: 'Find and Replace' },
+    { keys: ['mod', 'shift', 'f'], command: 'search.global', label: 'Search in Files' },
+    // View
+    { keys: ['mod', 'b'], command: 'view.sidebar', label: 'Toggle Sidebar' },
+    { keys: ['mod', 'j'], command: 'view.panel', label: 'Toggle Panel' },
+    { keys: ['mod', '`'], command: 'view.terminal', label: 'Toggle Terminal' },
+    { keys: ['mod', 'shift', 'e'], command: 'view.explorer', label: 'Focus Explorer' },
+    { keys: ['mod', '\\'], command: 'view.splitEditor', label: 'Split Editor' },
+    { keys: ['mod', 'k', 'z'], command: 'view.zenMode', label: 'Toggle Zen Mode' },
+    // Editor
+    { keys: ['mod', '/'], command: 'editor.toggleComment', label: 'Toggle Comment' },
+    { keys: ['mod', 'd'], command: 'editor.addSelection', label: 'Add Selection' },
+    { keys: ['mod', 'shift', 'k'], command: 'editor.deleteLine', label: 'Delete Line' },
+    { keys: ['alt', 'up'], command: 'editor.moveLineUp', label: 'Move Line Up' },
+    { keys: ['alt', 'down'], command: 'editor.moveLineDown', label: 'Move Line Down' },
+    { keys: ['mod', '['], command: 'editor.outdent', label: 'Outdent Line' },
+    { keys: ['mod', ']'], command: 'editor.indent', label: 'Indent Line' },
+    { keys: ['mod', 'z'], command: 'editor.undo', label: 'Undo' },
+    { keys: ['mod', 'shift', 'z'], command: 'editor.redo', label: 'Redo' },
+    // AI
+    { keys: ['mod', 'i'], command: 'ai.toggle', label: 'Toggle AI Panel' },
+    { keys: ['mod', 'shift', 'i'], command: 'ai.explain', label: 'Explain Selection' },
+    { keys: ['mod', 'k'], command: 'ai.inline', label: 'Inline AI Edit' }
+];

package/dist/utils/language.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Language detection and utilities
+ */
+/**
+ * Detect language from filename
+ */
+export declare function detectLanguage(filename: string): string;
+/**
+ * Get file extension (lowercase, without dot)
+ */
+export declare function getExtension(filename: string): string;
+/**
+ * Get MIME type for a language
+ */
+export declare function getLanguageMimeType(language: string): string;
+/**
+ * Check if a language is supported for syntax highlighting
+ */
+export declare function isLanguageSupported(language: string): boolean;
+/**
+ * Get display name for a language
+ */
+export declare function getLanguageDisplayName(language: string): string;
+/**
+ * Get icon name for a language (for use with icon components)
+ */
+export declare function getLanguageIcon(language: string): string;

package/dist/utils/language.js

@@ -0,0 +1,222 @@
+/**
+ * Language detection and utilities
+ */
+const extensionToLanguage = {
+    // JavaScript / TypeScript
+    js: 'javascript',
+    mjs: 'javascript',
+    cjs: 'javascript',
+    jsx: 'javascript',
+    ts: 'typescript',
+    tsx: 'typescript',
+    mts: 'typescript',
+    cts: 'typescript',
+    // Web
+    html: 'html',
+    htm: 'html',
+    css: 'css',
+    scss: 'css',
+    sass: 'css',
+    less: 'css',
+    // Data formats
+    json: 'json',
+    jsonc: 'json',
+    yaml: 'yaml',
+    yml: 'yaml',
+    toml: 'toml',
+    xml: 'xml',
+    svg: 'xml',
+    // Markdown
+    md: 'markdown',
+    mdx: 'markdown',
+    markdown: 'markdown',
+    // Programming languages
+    py: 'python',
+    pyw: 'python',
+    go: 'go',
+    rs: 'rust',
+    java: 'java',
+    kt: 'kotlin',
+    kts: 'kotlin',
+    scala: 'scala',
+    c: 'cpp',
+    cpp: 'cpp',
+    cc: 'cpp',
+    cxx: 'cpp',
+    h: 'cpp',
+    hpp: 'cpp',
+    hxx: 'cpp',
+    cs: 'csharp',
+    rb: 'ruby',
+    php: 'php',
+    swift: 'swift',
+    // Shell
+    sh: 'shell',
+    bash: 'shell',
+    zsh: 'shell',
+    fish: 'shell',
+    ps1: 'powershell',
+    psm1: 'powershell',
+    // Database
+    sql: 'sql',
+    psql: 'sql',
+    mysql: 'sql',
+    // Config
+    dockerfile: 'dockerfile',
+    makefile: 'makefile',
+    cmake: 'cmake',
+    // Svelte
+    svelte: 'svelte',
+    // Vue
+    vue: 'vue'
+};
+const filenameToLanguage = {
+    dockerfile: 'dockerfile',
+    makefile: 'makefile',
+    cmakelists: 'cmake',
+    gemfile: 'ruby',
+    rakefile: 'ruby',
+    vagrantfile: 'ruby',
+    jenkinsfile: 'groovy',
+    '.gitignore': 'gitignore',
+    '.gitattributes': 'gitattributes',
+    '.editorconfig': 'editorconfig',
+    '.env': 'dotenv',
+    '.env.local': 'dotenv',
+    '.env.development': 'dotenv',
+    '.env.production': 'dotenv'
+};
+/**
+ * Detect language from filename
+ */
+export function detectLanguage(filename) {
+    const lowerFilename = filename.toLowerCase();
+    // Check exact filename matches first
+    if (filenameToLanguage[lowerFilename]) {
+        return filenameToLanguage[lowerFilename];
+    }
+    // Check for files without extension but known names
+    const baseName = lowerFilename.split('/').pop() ?? lowerFilename;
+    if (filenameToLanguage[baseName]) {
+        return filenameToLanguage[baseName];
+    }
+    // Get extension
+    const ext = getExtension(filename);
+    if (ext && extensionToLanguage[ext]) {
+        return extensionToLanguage[ext];
+    }
+    return 'plaintext';
+}
+/**
+ * Get file extension (lowercase, without dot)
+ */
+export function getExtension(filename) {
+    const lastDot = filename.lastIndexOf('.');
+    if (lastDot === -1 || lastDot === filename.length - 1) {
+        return '';
+    }
+    return filename.slice(lastDot + 1).toLowerCase();
+}
+/**
+ * Get MIME type for a language
+ */
+export function getLanguageMimeType(language) {
+    const mimeTypes = {
+        javascript: 'text/javascript',
+        typescript: 'text/typescript',
+        html: 'text/html',
+        css: 'text/css',
+        json: 'application/json',
+        xml: 'application/xml',
+        markdown: 'text/markdown',
+        python: 'text/x-python',
+        go: 'text/x-go',
+        rust: 'text/x-rust',
+        java: 'text/x-java',
+        cpp: 'text/x-c++src',
+        sql: 'text/x-sql',
+        yaml: 'text/x-yaml',
+        plaintext: 'text/plain'
+    };
+    return mimeTypes[language] ?? 'text/plain';
+}
+/**
+ * Check if a language is supported for syntax highlighting
+ */
+export function isLanguageSupported(language) {
+    const supported = [
+        'javascript',
+        'typescript',
+        'html',
+        'css',
+        'json',
+        'markdown',
+        'python',
+        'go',
+        'rust',
+        'java',
+        'cpp',
+        'sql',
+        'xml',
+        'yaml',
+        'php'
+    ];
+    return supported.includes(language);
+}
+/**
+ * Get display name for a language
+ */
+export function getLanguageDisplayName(language) {
+    const displayNames = {
+        javascript: 'JavaScript',
+        typescript: 'TypeScript',
+        html: 'HTML',
+        css: 'CSS',
+        json: 'JSON',
+        xml: 'XML',
+        yaml: 'YAML',
+        markdown: 'Markdown',
+        python: 'Python',
+        go: 'Go',
+        rust: 'Rust',
+        java: 'Java',
+        kotlin: 'Kotlin',
+        scala: 'Scala',
+        cpp: 'C++',
+        csharp: 'C#',
+        ruby: 'Ruby',
+        php: 'PHP',
+        swift: 'Swift',
+        sql: 'SQL',
+        shell: 'Shell',
+        powershell: 'PowerShell',
+        dockerfile: 'Dockerfile',
+        makefile: 'Makefile',
+        svelte: 'Svelte',
+        vue: 'Vue',
+        plaintext: 'Plain Text'
+    };
+    return displayNames[language] ?? language.charAt(0).toUpperCase() + language.slice(1);
+}
+/**
+ * Get icon name for a language (for use with icon components)
+ */
+export function getLanguageIcon(language) {
+    // Returns icon identifiers that can be mapped to actual icons
+    const iconMap = {
+        javascript: 'file-js',
+        typescript: 'file-ts',
+        html: 'file-html',
+        css: 'file-css',
+        json: 'file-json',
+        markdown: 'file-md',
+        python: 'file-python',
+        go: 'file-go',
+        rust: 'file-rust',
+        java: 'file-java',
+        cpp: 'file-cpp',
+        svelte: 'file-svelte',
+        vue: 'file-vue'
+    };
+    return iconMap[language] ?? 'file';
+}