@nocturnium/svelte-ide 1.1.1 → 1.2.0

package/dist/components/editor/theme.js

@@ -20,8 +20,10 @@ export const tokenColors = {
     // Keywords
     keyword: 'var(--color-nocturnium-aurora-purple)',
     keywordControl: 'var(--color-nocturnium-aurora-purple)',
+    keywordOperator: 'var(--color-nocturnium-aurora-purple)',
     keywordDefinition: 'var(--color-nocturnium-aurora-purple)',
     keywordModule: 'var(--color-nocturnium-aurora-purple)',
+    keywordStorage: 'var(--color-nocturnium-aurora-purple)',
     // Operators
     operator: 'var(--ide-text-primary)',
     // Variables
@@ -34,20 +36,26 @@ export const tokenColors = {
     functionDefinition: 'var(--color-nocturnium-aurora-blue)',
     // Properties
     property: 'var(--color-nocturnium-wave)',
+    propertyDefinition: 'var(--color-nocturnium-wave)',
     // Types (distinct teal hue so types read differently from numbers/constants)
     type: 'var(--color-nocturnium-teal)',
     typeClass: 'var(--color-nocturnium-teal)',
+    typeInterface: 'var(--color-nocturnium-teal)',
+    typeNamespace: 'var(--color-nocturnium-teal)',
     typeBuiltin: 'var(--color-nocturnium-teal)',
     // Constants
     constant: 'var(--color-nocturnium-aurora-yellow)',
     constantBoolean: 'var(--color-nocturnium-aurora-yellow)',
     constantNull: 'var(--color-nocturnium-aurora-yellow)',
+    constantBuiltin: 'var(--color-nocturnium-aurora-yellow)',
     // Punctuation
     punctuation: 'var(--ide-text-secondary)',
+    punctuationBrace: 'var(--color-nocturnium-aurora-yellow)',
     // Tags (HTML/XML)
     tag: 'var(--color-nocturnium-aurora-pink)',
     tagAttribute: 'var(--color-nocturnium-aurora-yellow)',
     tagAttributeValue: 'var(--color-nocturnium-aurora-green)',
+    tagPunctuation: 'var(--ide-text-secondary)',
     // Markup (Markdown)
     markupHeading: 'var(--color-nocturnium-aurora-blue)',
     markupLink: 'var(--color-nocturnium-wave)',
@@ -107,18 +115,62 @@ export function getThemeCSS(theme = nocturniumTheme) {
 		/* Token Colors */
 		--editor-token-comment: ${theme.tokenColors.comment};
 		--editor-token-string: ${theme.tokenColors.string};
+		--editor-token-string-template: ${theme.tokenColors.stringTemplate};
+		--editor-token-string-regex: ${theme.tokenColors.stringRegex};
+		--editor-token-string-escape: ${theme.tokenColors.stringEscape};
 		--editor-token-number: ${theme.tokenColors.number};
 		--editor-token-keyword: ${theme.tokenColors.keyword};
+		--editor-token-keyword-control: ${theme.tokenColors.keywordControl};
+		--editor-token-keyword-operator: ${theme.tokenColors.keywordOperator};
+		--editor-token-keyword-definition: ${theme.tokenColors.keywordDefinition};
+		--editor-token-keyword-module: ${theme.tokenColors.keywordModule};
+		--editor-token-keyword-storage: ${theme.tokenColors.keywordStorage};
 		--editor-token-operator: ${theme.tokenColors.operator};
 		--editor-token-variable: ${theme.tokenColors.variable};
+		--editor-token-variable-definition: ${theme.tokenColors.variableDefinition};
+		--editor-token-variable-parameter: ${theme.tokenColors.variableParameter};
 		--editor-token-function: ${theme.tokenColors.function};
+		--editor-token-function-call: ${theme.tokenColors.functionCall};
+		--editor-token-function-definition: ${theme.tokenColors.functionDefinition};
 		--editor-token-property: ${theme.tokenColors.property};
+		--editor-token-property-definition: ${theme.tokenColors.propertyDefinition};
 		--editor-token-type: ${theme.tokenColors.type};
+		--editor-token-type-class: ${theme.tokenColors.typeClass};
+		--editor-token-type-interface: ${theme.tokenColors.typeInterface};
+		--editor-token-type-namespace: ${theme.tokenColors.typeNamespace};
+		--editor-token-type-builtin: ${theme.tokenColors.typeBuiltin};
 		--editor-token-constant: ${theme.tokenColors.constant};
+		--editor-token-constant-boolean: ${theme.tokenColors.constantBoolean};
+		--editor-token-constant-null: ${theme.tokenColors.constantNull};
+		--editor-token-constant-builtin: ${theme.tokenColors.constantBuiltin};
 		--editor-token-punctuation: ${theme.tokenColors.punctuation};
+		--editor-token-punctuation-brace: ${theme.tokenColors.punctuationBrace};
 		--editor-token-tag: ${theme.tokenColors.tag};
+		--editor-token-tag-attribute: ${theme.tokenColors.tagAttribute};
+		--editor-token-tag-attribute-value: ${theme.tokenColors.tagAttributeValue};
+		--editor-token-tag-punctuation: ${theme.tokenColors.tagPunctuation};
+		--editor-token-markup-heading: ${theme.tokenColors.markupHeading};
+		--editor-token-markup-link: ${theme.tokenColors.markupLink};
+		--editor-token-markup-code: ${theme.tokenColors.markupCode};
+		--editor-token-markup-quote: ${theme.tokenColors.markupQuote};
+		--editor-token-markup-list: ${theme.tokenColors.markupList};
 		--editor-token-invalid: ${theme.tokenColors.invalid};
 
+		/* Syntax aliases used by editor/code surfaces */
+		--ide-syntax-comment: ${theme.tokenColors.comment};
+		--ide-syntax-string: ${theme.tokenColors.string};
+		--ide-syntax-number: ${theme.tokenColors.number};
+		--ide-syntax-keyword: ${theme.tokenColors.keyword};
+		--ide-syntax-operator: ${theme.tokenColors.operator};
+		--ide-syntax-variable: ${theme.tokenColors.variable};
+		--ide-syntax-function: ${theme.tokenColors.function};
+		--ide-syntax-property: ${theme.tokenColors.property};
+		--ide-syntax-type: ${theme.tokenColors.type};
+		--ide-syntax-constant: ${theme.tokenColors.constant};
+		--ide-syntax-punctuation: ${theme.tokenColors.punctuation};
+		--ide-syntax-tag: ${theme.tokenColors.tag};
+		--ide-syntax-attribute: ${theme.tokenColors.tagAttribute};
+
 		/* Editor Colors */
 		--editor-bg: ${theme.editorColors.background};
 		--editor-bg-secondary: ${theme.editorColors.backgroundSecondary};

package/dist/services/lsp-client.d.ts

@@ -14,6 +14,7 @@ export declare class LSPClient {
     private reconnectAttempts;
     private reconnectTimeout;
     private intentionalDisconnect;
+    private incomingBuffer;
     private openDocuments;
     private diagnosticsCache;
     private eventHandlers;
@@ -35,6 +36,8 @@ export declare class LSPClient {
     disconnect(): Promise<void>;
     private initialize;
     private handleMessage;
+    private extractCompleteMessages;
+    private dispatchMessage;
     private sendRequest;
     private sendNotification;
     onNotification(method: string, handler: (params: unknown) => void): () => void;

package/dist/services/lsp-client.js

@@ -110,6 +110,7 @@ export class LSPClient {
     reconnectAttempts = 0;
     reconnectTimeout = null;
     intentionalDisconnect = false;
+    incomingBuffer = '';
     // Document tracking
     openDocuments = new Map();
     diagnosticsCache = new Map();
@@ -242,6 +243,7 @@ export class LSPClient {
         }
         if (socket === this.ws) {
             this.ws = null;
+            this.incomingBuffer = '';
         }
     }
     getReconnectDelay(attempt) {
@@ -331,49 +333,119 @@ export class LSPClient {
     // JSON-RPC Transport
     // ============================================================================
     handleMessage(data) {
+        this.incomingBuffer += data;
+        for (const rawMessage of this.extractCompleteMessages()) {
+            try {
+                const message = JSON.parse(rawMessage);
+                this.dispatchMessage(message);
+            }
+            catch (err) {
+                if (this.config.debug) {
+                    console.error('[LSP] Failed to parse message:', err);
+                }
+            }
+        }
+    }
+    extractCompleteMessages() {
+        const messages = [];
+        let start = -1;
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        let consumedUntil = 0;
+        for (let i = 0; i < this.incomingBuffer.length; i++) {
+            const char = this.incomingBuffer[i];
+            if (start === -1) {
+                if (/\s/.test(char)) {
+                    consumedUntil = i + 1;
+                    continue;
+                }
+                if (char !== '{') {
+                    consumedUntil = i + 1;
+                    continue;
+                }
+                start = i;
+                depth = 1;
+                continue;
+            }
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === '\\' && inString) {
+                escaped = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (inString) {
+                continue;
+            }
+            if (char === '{') {
+                depth++;
+            }
+            else if (char === '}') {
+                depth--;
+                if (depth === 0) {
+                    messages.push(this.incomingBuffer.slice(start, i + 1));
+                    start = -1;
+                    consumedUntil = i + 1;
+                }
+            }
+        }
+        this.incomingBuffer =
+            start === -1 ? this.incomingBuffer.slice(consumedUntil) : this.incomingBuffer.slice(start);
+        return messages;
+    }
+    dispatchMessage(message) {
         try {
-            const message = JSON.parse(data);
+            if (!message || typeof message !== 'object') {
+                return;
+            }
+            const rpcMessage = message;
             if (this.config.debug) {
-                console.log('[LSP] Received:', message);
+                console.log('[LSP] Received:', rpcMessage);
             }
-            if ('id' in message && message.id !== null) {
+            if ('id' in rpcMessage && rpcMessage.id !== null) {
                 // Response to a request
-                const pending = this.pendingRequests.get(message.id);
+                const pending = typeof rpcMessage.id === 'number' ? this.pendingRequests.get(rpcMessage.id) : undefined;
                 if (pending) {
                     clearTimeout(pending.timeout);
-                    this.pendingRequests.delete(message.id);
-                    if ('error' in message) {
-                        pending.reject(new Error(message.error.message));
+                    this.pendingRequests.delete(rpcMessage.id);
+                    if (rpcMessage.error) {
+                        pending.reject(new Error(rpcMessage.error.message));
                     }
                     else {
-                        pending.resolve(message.result);
+                        pending.resolve(rpcMessage.result);
                     }
                 }
             }
-            else if ('method' in message) {
+            else if (rpcMessage.method) {
                 // Server notification or request — dispatch to every subscriber.
-                const handlers = this.notificationHandlers.get(message.method);
+                const handlers = this.notificationHandlers.get(rpcMessage.method);
                 if (handlers && handlers.size > 0) {
                     // Iterate a copy so a handler can unsubscribe during dispatch.
                     for (const handler of [...handlers]) {
                         try {
-                            handler(message.params);
+                            handler(rpcMessage.params);
                         }
                         catch (err) {
                             if (this.config.debug) {
-                                console.error(`[LSP] Notification handler for "${message.method}" threw:`, err);
+                                console.error(`[LSP] Notification handler for "${rpcMessage.method}" threw:`, err);
                             }
                         }
                     }
                 }
                 else if (this.config.debug) {
-                    console.log(`[LSP] Unhandled notification: ${message.method}`);
+                    console.log(`[LSP] Unhandled notification: ${rpcMessage.method}`);
                 }
             }
         }
         catch (err) {
             if (this.config.debug) {
-                console.error('[LSP] Failed to parse message:', err);
+                console.error('[LSP] Failed to handle message:', err);
             }
         }
     }

package/dist/styles/theme.css

@@ -79,7 +79,10 @@
 	/* IDE Semantic Colors */
 	--ide-success: var(--color-nocturnium-aurora-green);
 	--ide-warning: var(--color-nocturnium-aurora-yellow);
-	--ide-error: #ef4444;
+	/* Lightened from #ef4444 (~4.1:1 on the secondary panel #1a2744, below AA)
+	   to ~5.5:1 so the critical band is AA-safe as small text, not only as the
+	   large/bold score numerals. */
+	--ide-error: #f87171;
 	--ide-info: var(--color-nocturnium-aurora-blue);
 
 	/* AI Panel Colors */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nocturnium/svelte-ide",
-	"version": "1.1.1",
+	"version": "1.2.0",
 	"description": "Svelte 5 code editor and IDE building blocks — custom editor, syntax highlighting, code folding, multi-cursor, LSP client, and optional realtime collaboration.",
 	"author": "Nocturnium & Jordan Dziat <hello@nocturnium.ai> (https://nocturnium.ai)",
 	"license": "MIT",