@nocturnium/svelte-ide 1.0.4 → 1.0.6

package/dist/components/editor/core/complexity-analyzer.js

@@ -19,7 +19,11 @@ const THRESHOLDS = {
  * Weights for different complexity factors
  */
 const WEIGHTS = {
-    nestingDepth: 15,
+    // Nesting is the dominant cognitive-load factor, but 15/level over-rated
+    // shallow code: a function with two nested `if`s landed at ~71 ("High").
+    // 12/level keeps deeply-nested code critical while letting genuinely medium
+    // code read as medium.
+    nestingDepth: 12,
     branchingFactor: 8,
     lineCount: 0.3,
     identifierCount: 0.2,
@@ -77,12 +81,15 @@ export class ComplexityAnalyzer {
      * Get complexity for a specific line
      */
     getLineComplexity(metrics, line) {
+        // A line can sit inside several nested regions; report the highest score
+        // so an inner low-complexity region never masks the hot function around it.
+        let best = 0;
         for (const region of metrics.regions) {
-            if (line >= region.startLine && line <= region.endLine) {
-                return region.score;
+            if (line >= region.startLine && line <= region.endLine && region.score > best) {
+                best = region.score;
             }
         }
-        return 0;
+        return best;
     }
     /**
      * Check if a line is a hotspot
@@ -117,10 +124,21 @@ export class ComplexityAnalyzer {
         // Track blocks with their brace depth at push time
         const blockStack = [];
         let braceDepth = 0;
+        let pendingDef;
         for (let i = 0; i < lines.length; i++) {
             const text = lines[i].text;
             // Check for function/class definition
             const funcMatch = text.match(PATTERNS.functionDef);
+            const currentBlock = blockStack[blockStack.length - 1];
+            const defCandidate = this.getDefinitionCandidate(text, funcMatch, currentBlock?.type === 'class' && braceDepth === currentBlock.depth);
+            if (defCandidate) {
+                pendingDef = {
+                    line: i,
+                    type: defCandidate.type,
+                    name: defCandidate.name,
+                    depth: braceDepth
+                };
+            }
             // Process character by character to properly match braces
             // Skip braces inside strings and comments
             let inString = null;
@@ -150,13 +168,16 @@ export class ComplexityAnalyzer {
                     if (c === '{') {
                         braceDepth++;
                         // If this is the opening brace of a function/class def, push it
-                        if (funcMatch && this.isDefOpeningBrace(text, ch, funcMatch)) {
+                        if (pendingDef &&
+                            braceDepth === pendingDef.depth + 1 &&
+                            this.isDefOpeningBrace(text, ch, pendingDef.type)) {
                             blockStack.push({
-                                line: i,
-                                type: funcMatch[5] ? 'class' : 'function',
-                                name: funcMatch[2] || funcMatch[3] || funcMatch[4] || funcMatch[5],
+                                line: pendingDef.line,
+                                type: pendingDef.type,
+                                name: pendingDef.name,
                                 depth: braceDepth
                             });
+                            pendingDef = undefined;
                         }
                         else if (!funcMatch ||
                             braceDepth > (blockStack.length > 0 ? blockStack[blockStack.length - 1].depth : 0) + 1) {
@@ -185,6 +206,9 @@ export class ComplexityAnalyzer {
                             }
                         }
                         braceDepth = Math.max(0, braceDepth - 1);
+                        if (pendingDef && braceDepth < pendingDef.depth) {
+                            pendingDef = undefined;
+                        }
                     }
                 }
             }
@@ -202,15 +226,49 @@ export class ComplexityAnalyzer {
     /**
      * Check if a `{` at position `ch` is the opening brace of a function/class definition
      */
-    isDefOpeningBrace(text, ch, funcMatch) {
+    isDefOpeningBrace(text, ch, type) {
         // For class: `class Foo {` — the `{` follows the class name
-        if (funcMatch[5]) {
+        if (type === 'class') {
             return true; // First `{` on a class line is the class body
         }
         // For functions: the `{` should follow the parameter list closing `)`
-        // or follow `=>` for arrow functions
+        // with an optional TypeScript return type, or follow `=>` for arrow functions.
         const before = text.slice(0, ch).trimEnd();
-        return before.endsWith(')') || before.endsWith('=>');
+        return /\)\s*(:\s*[^{};]+)?\s*$/.test(before) || before.endsWith('=>');
+    }
+    /**
+     * Extract a definition candidate before its body brace is seen.
+     */
+    getDefinitionCandidate(text, funcMatch, allowMethodStyle) {
+        if (funcMatch) {
+            // The arrow-assignment branch (`name = (`) also matches a parenthesised
+            // expression like `const x = (a - b) / c`, which is NOT a function.
+            // Only treat it as one when the line actually starts an arrow: it
+            // contains `=>`, or it has an unclosed `(` that opens a multi-line arrow
+            // signature. Otherwise the stale candidate gets attached to the next
+            // `if (...) {` block and a phantom region is reported.
+            const isArrowAssignment = !!funcMatch[3] && !funcMatch[2] && !funcMatch[4] && !funcMatch[5];
+            if (isArrowAssignment) {
+                const opens = (text.match(/\(/g) || []).length;
+                const closes = (text.match(/\)/g) || []).length;
+                if (!text.includes('=>') && opens <= closes) {
+                    return undefined;
+                }
+            }
+            return {
+                type: funcMatch[5] ? 'class' : 'function',
+                name: funcMatch[2] || funcMatch[3] || funcMatch[4] || funcMatch[5]
+            };
+        }
+        if (!allowMethodStyle) {
+            return undefined;
+        }
+        const trimmed = text.trim();
+        const methodMatch = trimmed.match(/^(?:(?:public|private|protected|static|async|readonly|override)\s+)*(?!(?:if|else|for|while|do|switch|try|catch|finally|with|return|throw|new|typeof|void|delete|await|yield)\b)(\w+)\s*\(/);
+        if (methodMatch) {
+            return { type: 'function', name: methodMatch[1] };
+        }
+        return undefined;
     }
     /**
      * Analyze a specific region

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

@@ -235,13 +235,13 @@ export function getSeverityIcon(severity) {
 export function getSeverityColor(severity) {
     switch (severity) {
         case 'error':
-            return '#f44747';
+            return 'var(--ide-error)';
         case 'warning':
-            return '#ff8c00';
+            return 'var(--ide-warning)';
         case 'info':
-            return '#3794ff';
+            return 'var(--ide-info)';
         case 'hint':
-            return '#6c6c6c';
+            return 'var(--ide-text-muted)';
     }
 }
 /**

package/dist/components/editor/core/semantic-analyzer.js

@@ -71,8 +71,9 @@ const JAVASCRIPT_PATTERNS = new Map([
     [
         'function',
         {
-            startPattern: /^(export\s+)?(async\s+)?function\s+(\w+)|^const\s+(\w+)\s*=\s*(async\s*)?\([^)]*\)\s*=>/,
+            startPattern: /^(export\s+)?(async\s+)?function\s+(\w+)|^(?:export\s+)?const\s+(\w+)\s*=\s*(async\s*)?\([^)]*\)\s*(?::[^=]+)?=>/,
             blockBased: true,
+            expressionBody: true,
             getLabel: (m) => `Function: ${m[3] || m[4] || 'anonymous'}`
         }
     ],
@@ -298,6 +299,17 @@ export class SemanticAnalyzer {
                             label: config.getLabel?.(match)
                         });
                     }
+                    else if (match && config.expressionBody && text.includes('=>')) {
+                        // Brace-less expression-bodied arrow (e.g. `export const f = () => x`):
+                        // no block to track, so record it as a single-line region.
+                        regions.push({
+                            category,
+                            startLine: i,
+                            endLine: i,
+                            confidence: 0.85,
+                            label: config.getLabel?.(match)
+                        });
+                    }
                 }
             }
             // Update depth

package/dist/components/editor/core/structure-layout.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Structure Map row layout
+ *
+ * The Structure Map places one labeled row per semantic region. Rows want to sit
+ * at a position proportional to their start line (so the map reads like a
+ * minimap), but every label needs a minimum pixel height to stay legible. With
+ * pure proportional placement, regions that start on the same line (e.g. the
+ * `exports` and `class` regions of `export class Foo`) or that cluster densely
+ * (a run of test hooks) overprint each other into illegible mush.
+ *
+ * `layoutStructureRows` resolves non-overlapping vertical offsets:
+ *  - pass 1 (top-down): no row sits closer than `rowHeight` below the previous
+ *    one, preserving proportional placement wherever there is room;
+ *  - pass 2 (bottom-up): if the de-collided stack overruns the available height,
+ *    pull rows back up so the last one ends exactly at `height`, keeping the
+ *    minimum spacing intact.
+ *
+ * When there are genuinely more rows than can fit (`rows * rowHeight > height`)
+ * the stack is floored at the top and rows are placed sequentially; callers are
+ * expected to clip the overflow (`overflow: hidden`).
+ */
+/**
+ * Resolve non-overlapping top offsets (in px) for structure-map rows.
+ *
+ * @param startLines  0-based start line of each row, in render order.
+ * @param totalLines  Total line count the map represents.
+ * @param height      Available height of the rendering area, in px.
+ * @param rowHeight   Minimum legible height of a single row, in px.
+ * @returns Top offset in px for each input row, in the same order.
+ */
+export declare function layoutStructureRows(startLines: readonly number[], totalLines: number, height: number, rowHeight: number): number[];

package/dist/components/editor/core/structure-layout.js

@@ -0,0 +1,64 @@
+/**
+ * Structure Map row layout
+ *
+ * The Structure Map places one labeled row per semantic region. Rows want to sit
+ * at a position proportional to their start line (so the map reads like a
+ * minimap), but every label needs a minimum pixel height to stay legible. With
+ * pure proportional placement, regions that start on the same line (e.g. the
+ * `exports` and `class` regions of `export class Foo`) or that cluster densely
+ * (a run of test hooks) overprint each other into illegible mush.
+ *
+ * `layoutStructureRows` resolves non-overlapping vertical offsets:
+ *  - pass 1 (top-down): no row sits closer than `rowHeight` below the previous
+ *    one, preserving proportional placement wherever there is room;
+ *  - pass 2 (bottom-up): if the de-collided stack overruns the available height,
+ *    pull rows back up so the last one ends exactly at `height`, keeping the
+ *    minimum spacing intact.
+ *
+ * When there are genuinely more rows than can fit (`rows * rowHeight > height`)
+ * the stack is floored at the top and rows are placed sequentially; callers are
+ * expected to clip the overflow (`overflow: hidden`).
+ */
+/**
+ * Resolve non-overlapping top offsets (in px) for structure-map rows.
+ *
+ * @param startLines  0-based start line of each row, in render order.
+ * @param totalLines  Total line count the map represents.
+ * @param height      Available height of the rendering area, in px.
+ * @param rowHeight   Minimum legible height of a single row, in px.
+ * @returns Top offset in px for each input row, in the same order.
+ */
+export function layoutStructureRows(startLines, totalLines, height, rowHeight) {
+    const n = startLines.length;
+    if (n === 0)
+        return [];
+    const span = Math.max(1, totalLines);
+    const tops = startLines.map((line) => (Math.max(0, line) / span) * height);
+    // Pass 1 — top-down: enforce the minimum gap, keeping proportional order.
+    for (let i = 1; i < n; i++) {
+        const min = tops[i - 1] + rowHeight;
+        if (tops[i] < min)
+            tops[i] = min;
+    }
+    // Pass 2 — bottom-up: if the stack overflows, slide it back into bounds.
+    if (height > 0 && tops[n - 1] + rowHeight > height) {
+        tops[n - 1] = height - rowHeight;
+        for (let i = n - 2; i >= 0; i--) {
+            const max = tops[i + 1] - rowHeight;
+            if (tops[i] > max)
+                tops[i] = max;
+        }
+        // More rows than fit: floor at the top and place sequentially. Some
+        // overlap is unavoidable here, but the result is deterministic and the
+        // caller clips it.
+        if (tops[0] < 0) {
+            tops[0] = 0;
+            for (let i = 1; i < n; i++) {
+                const min = tops[i - 1] + rowHeight;
+                if (tops[i] < min)
+                    tops[i] = min;
+            }
+        }
+    }
+    return tops;
+}

package/dist/styles/theme.css

@@ -65,6 +65,12 @@
 	--ide-interactive-muted: color-mix(in srgb, var(--ide-interactive) 70%, transparent);
 	--ide-interactive-rgb: 74, 141, 183;
 
+	/* Primary action — the signature warm ember accent, shared as a single
+	   source of truth by primary buttons and badges so "primary" reads the
+	   same everywhere. */
+	--ide-primary: var(--ide-interactive-active);
+	--ide-primary-hover: var(--ide-interactive-hover);
+
 	/* IDE Accent Colors */
 	--ide-accent: var(--color-nocturnium-wave);
 	--ide-accent-hover: var(--color-nocturnium-flame);
@@ -85,11 +91,14 @@
 
 	/* Plugin Status Colors */
 	--ide-plugin-draft: var(--ide-text-muted);
+	--ide-plugin-submitted: var(--ide-info);
 	--ide-plugin-reviewing: var(--color-nocturnium-aurora-yellow);
 	--ide-plugin-approved: var(--color-nocturnium-aurora-green);
+	--ide-plugin-testing: var(--color-nocturnium-teal);
 	--ide-plugin-rejected: var(--ide-error);
 	--ide-plugin-deploying: var(--color-nocturnium-aurora-blue);
 	--ide-plugin-deployed: var(--color-nocturnium-aurora-green);
+	--ide-plugin-rolled_back: var(--color-nocturnium-flame);
 
 	/* CRDT Collaboration Colors */
 	--ide-collab-cursor-1: var(--color-nocturnium-aurora-blue);
@@ -397,6 +406,11 @@
 	color: var(--ide-plugin-draft);
 }
 
+.ide-plugin-status--submitted {
+	background-color: color-mix(in srgb, var(--ide-plugin-submitted) 20%, transparent);
+	color: var(--ide-plugin-submitted);
+}
+
 .ide-plugin-status--reviewing {
 	background-color: color-mix(in srgb, var(--ide-plugin-reviewing) 20%, transparent);
 	color: var(--ide-plugin-reviewing);
@@ -407,6 +421,11 @@
 	color: var(--ide-plugin-approved);
 }
 
+.ide-plugin-status--testing {
+	background-color: color-mix(in srgb, var(--ide-plugin-testing) 20%, transparent);
+	color: var(--ide-plugin-testing);
+}
+
 .ide-plugin-status--rejected {
 	background-color: color-mix(in srgb, var(--ide-plugin-rejected) 20%, transparent);
 	color: var(--ide-plugin-rejected);
@@ -422,6 +441,11 @@
 	color: var(--ide-plugin-deployed);
 }
 
+.ide-plugin-status--rolled_back {
+	background-color: color-mix(in srgb, var(--ide-plugin-rolled_back) 20%, transparent);
+	color: var(--ide-plugin-rolled_back);
+}
+
 /* Agent Status Animations */
 @keyframes ide-agent-pulse {
 	0%,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nocturnium/svelte-ide",
-	"version": "1.0.4",
+	"version": "1.0.6",
 	"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",