@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/components/editor/editor-multicursor.js

@@ -0,0 +1,196 @@
+/**
+ * Multi-cursor selection helpers extracted from CustomEditor.
+ * Pure functions that operate on EditorState.
+ */
+import { findAllMatches, getSelectionStart, getSelectionEnd, isSelectionEmpty } from './core';
+/**
+ * Test whether a character is a word character (\w). Used to enforce whole-word
+ * boundaries so that selecting `foo` does not also land cursors inside `foobar`.
+ */
+function isWordChar(c) {
+    return c !== undefined && /\w/.test(c);
+}
+/**
+ * Find all matches of `searchText` across the document.
+ *
+ * - When `wholeWord` is true, matches are filtered so that the characters
+ *   immediately before and after the match are NOT word characters. This is the
+ *   "select word under cursor" behaviour where `foo` should not match `foobar`.
+ * - Multi-line search text (containing a newline) is the caller's responsibility
+ *   to handle; this helper only ever sees single-line search text because the
+ *   per-line search engine cannot span lines.
+ */
+function findOccurrences(state, searchText, wholeWord) {
+    const matches = findAllMatches(state.lines, searchText, {
+        caseSensitive: true,
+        useRegex: false
+    });
+    if (!wholeWord)
+        return matches;
+    if (!isWordChar(searchText[0]) && !isWordChar(searchText[searchText.length - 1])) {
+        // The search text is not bounded by word characters at all (e.g. an
+        // operator or punctuation), so word-boundary filtering is meaningless.
+        return matches;
+    }
+    return matches.filter((m) => {
+        const lineText = state.getLine(m.start.line)?.text ?? '';
+        const before = m.start.column > 0 ? lineText[m.start.column - 1] : undefined;
+        const after = lineText[m.end.column];
+        return !isWordChar(before) && !isWordChar(after);
+    });
+}
+/**
+ * Get word at cursor position
+ */
+export function getWordAtPosition(state, pos) {
+    const line = state.getLine(pos.line);
+    if (!line)
+        return null;
+    const text = line.text;
+    if (!text || pos.column >= text.length)
+        return null;
+    // Find word boundaries
+    let start = pos.column;
+    let end = pos.column;
+    const isWordChar = (c) => /\w/.test(c);
+    // Move start backwards
+    while (start > 0 && isWordChar(text[start - 1])) {
+        start--;
+    }
+    // Move end forwards
+    while (end < text.length && isWordChar(text[end])) {
+        end++;
+    }
+    if (start === end)
+        return null;
+    return {
+        text: text.slice(start, end),
+        start: { line: pos.line, column: start },
+        end: { line: pos.line, column: end }
+    };
+}
+/**
+ * Select next occurrence of current word/selection (Ctrl+D)
+ */
+export function selectNextOccurrence(state) {
+    if (!state)
+        return;
+    const primary = state.primaryCursor;
+    let searchText;
+    // Whole-word matching only applies to the implicit "word under cursor" case;
+    // an explicit selection should match exactly as selected (substring).
+    let wholeWord = false;
+    // Get text to search for
+    if (!isSelectionEmpty(primary.selection)) {
+        // Use current selection
+        searchText = state.getTextInSelection(primary.selection);
+    }
+    else {
+        // Select word at cursor first
+        const word = getWordAtPosition(state, primary.selection.head);
+        if (!word)
+            return;
+        searchText = word.text;
+        wholeWord = true;
+        // Select the word under cursor for the primary cursor
+        state.cursorManager.setSelection(primary.id, word.start, word.end);
+    }
+    if (!searchText)
+        return;
+    // A multi-line selection cannot be matched by the per-line search engine, so
+    // bail out cleanly rather than silently searching for the (never-found) text.
+    if (searchText.includes('\n'))
+        return;
+    // Find all matches (whole-word filtered for the word-under-cursor case)
+    const matches = findOccurrences(state, searchText, wholeWord);
+    if (matches.length === 0)
+        return;
+    // Get all current cursor positions to find next unselected match
+    const currentCursors = state.allCursors;
+    // Find next match after the last cursor that isn't already selected
+    let lastCursorEnd = { line: 0, column: 0 };
+    for (const cursor of currentCursors) {
+        const end = getSelectionEnd(cursor.selection);
+        if (end.line > lastCursorEnd.line ||
+            (end.line === lastCursorEnd.line && end.column > lastCursorEnd.column)) {
+            lastCursorEnd = end;
+        }
+    }
+    // Find next match
+    let foundMatch = null;
+    for (const match of matches) {
+        const matchStart = match.start;
+        if (matchStart.line > lastCursorEnd.line ||
+            (matchStart.line === lastCursorEnd.line && matchStart.column >= lastCursorEnd.column)) {
+            // Check if this match is already covered by a cursor
+            const alreadySelected = currentCursors.some(cursor => {
+                const start = getSelectionStart(cursor.selection);
+                return start.line === matchStart.line && start.column === matchStart.column;
+            });
+            if (!alreadySelected) {
+                foundMatch = match;
+                break;
+            }
+        }
+    }
+    // If no match found after last cursor, wrap around
+    if (!foundMatch) {
+        for (const match of matches) {
+            const matchStart = match.start;
+            const alreadySelected = currentCursors.some(cursor => {
+                const start = getSelectionStart(cursor.selection);
+                return start.line === matchStart.line && start.column === matchStart.column;
+            });
+            if (!alreadySelected) {
+                foundMatch = match;
+                break;
+            }
+        }
+    }
+    if (foundMatch) {
+        state.addCursorWithSelection(foundMatch.start, foundMatch.end);
+    }
+}
+/**
+ * Select all occurrences of current word/selection (Ctrl+Shift+L)
+ */
+export function selectAllOccurrences(state) {
+    if (!state)
+        return;
+    const primary = state.primaryCursor;
+    let searchText;
+    // Whole-word matching only applies to the implicit "word under cursor" case.
+    let wholeWord = false;
+    // Get text to search for
+    if (!isSelectionEmpty(primary.selection)) {
+        searchText = state.getTextInSelection(primary.selection);
+    }
+    else {
+        const word = getWordAtPosition(state, primary.selection.head);
+        if (!word)
+            return;
+        searchText = word.text;
+        wholeWord = true;
+        // Select the word under cursor for the primary cursor
+        state.cursorManager.setSelection(primary.id, word.start, word.end);
+    }
+    if (!searchText)
+        return;
+    // A multi-line selection cannot be matched by the per-line search engine.
+    if (searchText.includes('\n'))
+        return;
+    // Find all matches (whole-word filtered for the word-under-cursor case)
+    const matches = findOccurrences(state, searchText, wholeWord);
+    if (matches.length <= 1)
+        return;
+    // Add cursors at all other matches
+    for (const match of matches) {
+        const matchStart = match.start;
+        // Skip the primary cursor's position
+        const primaryStart = getSelectionStart(primary.selection);
+        if (matchStart.line === primaryStart.line && matchStart.column === primaryStart.column) {
+            continue;
+        }
+        state.addCursorWithSelection(match.start, match.end);
+    }
+}

package/dist/components/editor/editor-scroll.d.ts

@@ -0,0 +1,14 @@
+import type { Selection } from './core';
+export interface ScrollConfig {
+    getEditorContent: () => HTMLDivElement | null;
+    getSelection: () => Selection;
+    getMeasurements: () => {
+        lineHeight: number;
+        charWidth: number;
+        gutterWidth: number;
+        contentPadding: number;
+    };
+}
+export declare function createEditorScroll(config: ScrollConfig): {
+    scrollCursorIntoView: () => Promise<void>;
+};

package/dist/components/editor/editor-scroll.js

@@ -0,0 +1,34 @@
+import { tick } from 'svelte';
+import { CONTENT_PADDING } from './constants';
+export function createEditorScroll(config) {
+    async function scrollCursorIntoView() {
+        await tick();
+        const editorContent = config.getEditorContent();
+        if (!editorContent)
+            return;
+        const selection = config.getSelection();
+        const { lineHeight, charWidth, gutterWidth } = config.getMeasurements();
+        const cursorTop = selection.head.line * lineHeight;
+        const cursorLeft = gutterWidth + CONTENT_PADDING + selection.head.column * charWidth;
+        const viewportHeight = editorContent.clientHeight;
+        const viewportWidth = editorContent.clientWidth;
+        const scrollTop = editorContent.scrollTop;
+        const scrollLeft = editorContent.scrollLeft;
+        // Vertical scroll
+        if (cursorTop < scrollTop) {
+            editorContent.scrollTop = cursorTop;
+        }
+        else if (cursorTop + lineHeight > scrollTop + viewportHeight) {
+            editorContent.scrollTop = cursorTop + lineHeight - viewportHeight;
+        }
+        // Horizontal scroll
+        const contentStart = gutterWidth + CONTENT_PADDING;
+        if (cursorLeft < scrollLeft + contentStart) {
+            editorContent.scrollLeft = Math.max(0, cursorLeft - contentStart - 20);
+        }
+        else if (cursorLeft > scrollLeft + viewportWidth - 20) {
+            editorContent.scrollLeft = cursorLeft - viewportWidth + 40;
+        }
+    }
+    return { scrollCursorIntoView };
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Editor components and utilities
+ */
+export { default as Editor } from './Editor.svelte';
+export { default as CustomEditor } from './CustomEditor.svelte';
+export { default as CollaborativeEditor } from './CollaborativeEditor.svelte';
+export { default as EditorTabs } from './EditorTabs.svelte';
+export { default as EditorPane } from './EditorPane.svelte';
+export { default as FileIcon } from './FileIcon.svelte';
+export { default as FileExplorer } from './FileExplorer.svelte';
+export * from './core';
+export * from './theme';
+export { getLanguageExtension, getLanguageConfig, getLanguageFromExtension, getLanguageFromFilename, getLanguageFromMimeType, getAllLanguageConfigs, resolveLanguage, type LanguageConfig } from './languages';
+export { getSupportedLanguages, isLanguageSupported } from './languages';
+export { getTokenizer, tokenize, getTokenClass, tokensToHTML, PlaintextTokenizer, SimpleTokenizer, GrammarTokenizer, createToken, type Token, type TokenizedLine, type TokenizerState, type TokenType, type LanguageTokenizer, type TokenRule, type LanguageGrammar } from './tokenizer';

package/dist/components/editor/index.js

@@ -0,0 +1,21 @@
+/**
+ * Editor components and utilities
+ */
+// Components
+export { default as Editor } from './Editor.svelte';
+export { default as CustomEditor } from './CustomEditor.svelte';
+export { default as CollaborativeEditor } from './CollaborativeEditor.svelte';
+export { default as EditorTabs } from './EditorTabs.svelte';
+export { default as EditorPane } from './EditorPane.svelte';
+export { default as FileIcon } from './FileIcon.svelte';
+export { default as FileExplorer } from './FileExplorer.svelte';
+// Core utilities
+export * from './core';
+// Theme
+export * from './theme';
+// Languages (explicit exports to avoid conflicts with tokenizer)
+export { getLanguageExtension, getLanguageConfig, getLanguageFromExtension, getLanguageFromFilename, getLanguageFromMimeType, getAllLanguageConfigs, resolveLanguage } from './languages';
+// Re-export from languages (these exist in both but we prefer languages versions)
+export { getSupportedLanguages, isLanguageSupported } from './languages';
+// Tokenizer (explicit exports to avoid conflicts)
+export { getTokenizer, tokenize, getTokenClass, tokensToHTML, PlaintextTokenizer, SimpleTokenizer, GrammarTokenizer, createToken } from './tokenizer';

package/dist/components/editor/languages.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Language support for the custom editor
+ *
+ * This module provides language detection and configuration
+ * using the custom tokenizer system (no CodeMirror dependency).
+ */
+/**
+ * Language configuration
+ */
+export interface LanguageConfig {
+    /** Language identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** File extensions (without dot) */
+    extensions: string[];
+    /** MIME types */
+    mimeTypes: string[];
+    /** Line comment prefix */
+    lineComment?: string;
+    /** Block comment delimiters */
+    blockComment?: [string, string];
+    /** Auto-closing pairs */
+    autoClosingPairs?: Array<[string, string]>;
+    /** Surrounding pairs */
+    surroundingPairs?: Array<[string, string]>;
+    /** Word pattern regex */
+    wordPattern?: RegExp;
+}
+/**
+ * Get language ID from file extension
+ */
+export declare function getLanguageFromExtension(extension: string): string;
+/**
+ * Get language ID from MIME type
+ */
+export declare function getLanguageFromMimeType(mimeType: string): string;
+/**
+ * Get language ID from filename
+ */
+export declare function getLanguageFromFilename(filename: string): string;
+/**
+ * Get language configuration
+ */
+export declare function getLanguageConfig(language: string): LanguageConfig;
+/**
+ * Check if a language is supported
+ */
+export declare function isLanguageSupported(language: string): boolean;
+/**
+ * Get list of supported languages
+ */
+export declare function getSupportedLanguages(): string[];
+/**
+ * Get all language configurations
+ */
+export declare function getAllLanguageConfigs(): LanguageConfig[];
+/**
+ * @deprecated Use getLanguageConfig instead
+ */
+export declare function getLanguageExtension(language: string): Promise<string | null>;
+export { resolveLanguage } from './tokenizer';

package/dist/components/editor/languages.js

@@ -0,0 +1,285 @@
+/**
+ * Language support for the custom editor
+ *
+ * This module provides language detection and configuration
+ * using the custom tokenizer system (no CodeMirror dependency).
+ */
+import { resolveLanguage, isLanguageSupported as tokenizerSupported, getSupportedLanguages as getTokenizerLanguages } from './tokenizer';
+/**
+ * Language configurations
+ */
+const languages = {
+    javascript: {
+        id: 'javascript',
+        name: 'JavaScript',
+        extensions: ['js', 'mjs', 'cjs'],
+        mimeTypes: ['text/javascript', 'application/javascript'],
+        lineComment: '//',
+        blockComment: ['/*', '*/'],
+        autoClosingPairs: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['"', '"'],
+            ["'", "'"],
+            ['`', '`']
+        ],
+        surroundingPairs: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['"', '"'],
+            ["'", "'"],
+            ['`', '`']
+        ],
+        wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g
+    },
+    typescript: {
+        id: 'typescript',
+        name: 'TypeScript',
+        extensions: ['ts', 'mts', 'cts'],
+        mimeTypes: ['text/typescript', 'application/typescript'],
+        lineComment: '//',
+        blockComment: ['/*', '*/'],
+        autoClosingPairs: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['"', '"'],
+            ["'", "'"],
+            ['`', '`'],
+            ['<', '>']
+        ],
+        surroundingPairs: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['"', '"'],
+            ["'", "'"],
+            ['`', '`'],
+            ['<', '>']
+        ]
+    },
+    jsx: {
+        id: 'jsx',
+        name: 'JavaScript React',
+        extensions: ['jsx'],
+        mimeTypes: ['text/jsx'],
+        lineComment: '//',
+        blockComment: ['/*', '*/'],
+        autoClosingPairs: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['"', '"'],
+            ["'", "'"],
+            ['`', '`'],
+            ['<', '>']
+        ]
+    },
+    tsx: {
+        id: 'tsx',
+        name: 'TypeScript React',
+        extensions: ['tsx'],
+        mimeTypes: ['text/tsx'],
+        lineComment: '//',
+        blockComment: ['/*', '*/'],
+        autoClosingPairs: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['"', '"'],
+            ["'", "'"],
+            ['`', '`'],
+            ['<', '>']
+        ]
+    },
+    html: {
+        id: 'html',
+        name: 'HTML',
+        extensions: ['html', 'htm', 'xhtml'],
+        mimeTypes: ['text/html'],
+        blockComment: ['<!--', '-->'],
+        autoClosingPairs: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['"', '"'],
+            ["'", "'"],
+            ['<', '>']
+        ]
+    },
+    css: {
+        id: 'css',
+        name: 'CSS',
+        extensions: ['css'],
+        mimeTypes: ['text/css'],
+        blockComment: ['/*', '*/'],
+        autoClosingPairs: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['"', '"'],
+            ["'", "'"]
+        ]
+    },
+    json: {
+        id: 'json',
+        name: 'JSON',
+        extensions: ['json', 'jsonc', 'json5'],
+        mimeTypes: ['application/json'],
+        autoClosingPairs: [
+            ['{', '}'],
+            ['[', ']'],
+            ['"', '"']
+        ]
+    },
+    python: {
+        id: 'python',
+        name: 'Python',
+        extensions: ['py', 'pyw', 'pyi'],
+        mimeTypes: ['text/x-python'],
+        lineComment: '#',
+        autoClosingPairs: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['"', '"'],
+            ["'", "'"]
+        ]
+    },
+    go: {
+        id: 'go',
+        name: 'Go',
+        extensions: ['go'],
+        mimeTypes: ['text/x-go'],
+        lineComment: '//',
+        blockComment: ['/*', '*/'],
+        autoClosingPairs: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['"', '"'],
+            ["'", "'"],
+            ['`', '`']
+        ]
+    },
+    markdown: {
+        id: 'markdown',
+        name: 'Markdown',
+        extensions: ['md', 'markdown', 'mdown', 'mkd'],
+        mimeTypes: ['text/markdown'],
+        autoClosingPairs: [
+            ['[', ']'],
+            ['(', ')'],
+            ['"', '"'],
+            ["'", "'"],
+            ['`', '`'],
+            ['*', '*'],
+            ['_', '_']
+        ]
+    },
+    xml: {
+        id: 'xml',
+        name: 'XML',
+        extensions: ['xml', 'xsl', 'xslt', 'svg', 'rss', 'atom'],
+        mimeTypes: ['text/xml', 'application/xml'],
+        blockComment: ['<!--', '-->'],
+        autoClosingPairs: [
+            ['"', '"'],
+            ["'", "'"],
+            ['<', '>']
+        ]
+    },
+    yaml: {
+        id: 'yaml',
+        name: 'YAML',
+        extensions: ['yaml', 'yml'],
+        mimeTypes: ['text/yaml'],
+        lineComment: '#',
+        autoClosingPairs: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['"', '"'],
+            ["'", "'"]
+        ]
+    },
+    plaintext: {
+        id: 'plaintext',
+        name: 'Plain Text',
+        extensions: ['txt', 'text'],
+        mimeTypes: ['text/plain'],
+        autoClosingPairs: []
+    }
+};
+// Extension to language mapping
+const extensionMap = new Map();
+for (const [id, config] of Object.entries(languages)) {
+    for (const ext of config.extensions) {
+        extensionMap.set(ext.toLowerCase(), id);
+    }
+}
+// MIME type to language mapping
+const mimeMap = new Map();
+for (const [id, config] of Object.entries(languages)) {
+    for (const mime of config.mimeTypes) {
+        mimeMap.set(mime.toLowerCase(), id);
+    }
+}
+/**
+ * Get language ID from file extension
+ */
+export function getLanguageFromExtension(extension) {
+    const ext = extension.toLowerCase().replace(/^\./, '');
+    return extensionMap.get(ext) ?? 'plaintext';
+}
+/**
+ * Get language ID from MIME type
+ */
+export function getLanguageFromMimeType(mimeType) {
+    return mimeMap.get(mimeType.toLowerCase()) ?? 'plaintext';
+}
+/**
+ * Get language ID from filename
+ */
+export function getLanguageFromFilename(filename) {
+    const ext = filename.split('.').pop() ?? '';
+    return getLanguageFromExtension(ext);
+}
+/**
+ * Get language configuration
+ */
+export function getLanguageConfig(language) {
+    const resolved = resolveLanguage(language);
+    return languages[resolved] ?? languages['plaintext'];
+}
+/**
+ * Check if a language is supported
+ */
+export function isLanguageSupported(language) {
+    return tokenizerSupported(language);
+}
+/**
+ * Get list of supported languages
+ */
+export function getSupportedLanguages() {
+    return getTokenizerLanguages();
+}
+/**
+ * Get all language configurations
+ */
+export function getAllLanguageConfigs() {
+    return Object.values(languages);
+}
+// For backwards compatibility - these functions previously loaded CodeMirror extensions
+// Now they just return the language string since tokenization is handled internally
+/**
+ * @deprecated Use getLanguageConfig instead
+ */
+export async function getLanguageExtension(language) {
+    const resolved = resolveLanguage(language);
+    return isLanguageSupported(resolved) ? resolved : null;
+}
+// Re-export tokenizer functions for convenience
+export { resolveLanguage } from './tokenizer';