@nocturnium/svelte-ide 1.0.5 → 1.1.0

package/dist/components/editor/ComplexityLayer.svelte

@@ -83,9 +83,11 @@
 	 * Get the color based on score level
 	 */
 	function getColor(score: number): string {
-		if (score >= 85) return '#ef4444'; // Critical - red
-		if (score >= 70) return '#f59e0b'; // High - orange
-		return '#3b82f6'; // Medium - blue
+		// Bands match the analyzer's levels: critical >= 85, high >= 70,
+		// medium otherwise (lines below the minScore threshold aren't shown).
+		if (score >= 85) return 'var(--ide-error)'; // Critical
+		if (score >= 70) return 'var(--ide-warning)'; // High
+		return 'var(--ide-info)'; // Medium
 	}
 
 	/**

package/dist/components/editor/CustomEditor.svelte

@@ -26,7 +26,7 @@
 	import CommandPalette from './CommandPalette.svelte';
 	import { getComplexityAnalyzer, type ComplexityMetrics } from './core/complexity-analyzer';
 	import { registerSemanticFoldCommands } from './core/commands';
-	import { getSemanticAnalyzer } from './core/semantic-analyzer';
+	import { getSemanticAnalyzer, type FoldPreset } from './core/semantic-analyzer';
 	import type { AIAwareness } from './core/ai-awareness';
 	import {
 		CURSOR_BLINK_MS,
@@ -501,6 +501,50 @@
 		}
 	}
 
+	/**
+	 * Collapse every semantic region whose category is listed in `preset.hide`,
+	 * after first expanding everything so presets compose predictably. Shared by
+	 * the command-palette preset commands and the exported imperative API.
+	 */
+	function applyFoldPresetInternal(preset: FoldPreset) {
+		if (!folding || !editorState) return;
+		foldManager.expandAll();
+		const analyzer = getSemanticAnalyzer();
+		const semanticRegions = analyzer.analyze(editorState.lines, language);
+		const foldRegions = foldManager.getRegions();
+
+		// Semantic region boundaries don't always line up exactly with bracket-fold
+		// headers — a function's foldable `{` can sit a line below its doc-commented
+		// header, and a hidden category (e.g. `private`, `error-handling`) may cover
+		// several nested blocks. So collapse every foldable block whose header falls
+		// within a hidden semantic region's range, rather than requiring an exact
+		// header-line match (which silently folded almost nothing). collapse() is
+		// idempotent, so collapsing the same header twice is harmless.
+		for (const region of semanticRegions) {
+			if (!preset.hide.includes(region.category)) continue;
+			for (const fold of foldRegions) {
+				if (fold.startLine >= region.startLine && fold.startLine <= region.endLine) {
+					foldManager.collapse(fold.startLine);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Imperative API (accessible via `bind:this`): apply a semantic fold preset.
+	 */
+	export function applyFoldPreset(preset: FoldPreset) {
+		applyFoldPresetInternal(preset);
+	}
+
+	/**
+	 * Imperative API (accessible via `bind:this`): expand all folded regions.
+	 */
+	export function unfoldAll() {
+		if (!folding || !editorState) return;
+		foldManager.expandAll();
+	}
+
 	function handleFoldIndicatorClick(lineNumber: number, e: MouseEvent) {
 		e.preventDefault();
 		e.stopPropagation();
@@ -787,17 +831,7 @@
 				foldManager?.expandAll();
 			},
 			onApplyPreset: (preset) => {
-				// First expand all
-				foldManager?.expandAll();
-				// Then collapse categories that should be hidden
-				const analyzer = getSemanticAnalyzer();
-				const regions = analyzer.analyze(editorState.lines, language);
-				for (const category of preset.hide) {
-					const categoryRegions = analyzer.getByCategory(regions, category);
-					for (const region of categoryRegions) {
-						foldManager?.collapse(region.startLine);
-					}
-				}
+				applyFoldPresetInternal(preset);
 			},
 			getLanguage: () => language
 		});

package/dist/components/editor/CustomEditor.svelte.d.ts

@@ -1,6 +1,7 @@
 import type { EditorPreferences } from '../../types';
 import { type Cursor } from './core';
 import { type ComplexityMetrics } from './core/complexity-analyzer';
+import { type FoldPreset } from './core/semantic-analyzer';
 import type { AIAwareness } from './core/ai-awareness';
 interface Props {
     content: string;
@@ -32,6 +33,9 @@ interface Props {
     onComplexityChange?: (metrics: ComplexityMetrics | null) => void;
     onSave?: () => void;
 }
-declare const CustomEditor: import("svelte").Component<Props, {}, "content">;
+declare const CustomEditor: import("svelte").Component<Props, {
+    applyFoldPreset: (preset: FoldPreset) => void;
+    unfoldAll: () => void;
+}, "content">;
 type CustomEditor = ReturnType<typeof CustomEditor>;
 export default CustomEditor;

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
@@ -234,6 +241,20 @@ export class ComplexityAnalyzer {
      */
     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]

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

@@ -18,7 +18,7 @@ export interface FoldRegion {
     /** Indentation level (for nested folds) */
     level: number;
     /** Type of fold region */
-    type: 'bracket' | 'indentation' | 'region' | 'comment';
+    type: 'bracket' | 'indentation' | 'region' | 'comment' | 'import';
     /** Whether this region is currently collapsed */
     collapsed: boolean;
 }
@@ -34,12 +34,11 @@ export interface FoldingConfig {
     regions: boolean;
     /** Enable multi-line comment folding */
     comments: boolean;
+    /** Enable folding a run of consecutive import statements */
+    imports: boolean;
     /** Minimum lines for a foldable region */
     minLines: number;
 }
-/**
- * Detect all fold regions in a document
- */
 export declare function detectFoldRegions(lines: readonly Line[], language?: string, config?: Partial<FoldingConfig>): FoldRegion[];
 /**
  * Fold state manager

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

@@ -11,6 +11,7 @@ const DEFAULT_CONFIG = {
     indentation: true,
     regions: true,
     comments: true,
+    imports: true,
     minLines: 2
 };
 /**
@@ -424,6 +425,38 @@ function detectCommentFolds(lines, minLines = 2) {
 /**
  * Detect all fold regions in a document
  */
+/**
+ * Detect a fold region for each run of consecutive import statements. Import
+ * groups have no braces of their own, so without this an editor (and the
+ * "fold imports" semantic preset) can't collapse them.
+ */
+function detectImportFolds(lines, minLines = 2) {
+    const regions = [];
+    // ES `import ... from`, side-effect `import '...'`, and Python `from x import`.
+    const isImportLine = (text) => /^\s*import\b/.test(text) || /^\s*from\s+\S+\s+import\b/.test(text);
+    let start = -1;
+    for (let i = 0; i <= lines.length; i++) {
+        const isImport = i < lines.length && isImportLine(lines[i].text);
+        if (isImport) {
+            if (start === -1)
+                start = i;
+        }
+        else if (start !== -1) {
+            const end = i - 1;
+            if (end - start + 1 >= minLines) {
+                regions.push({
+                    startLine: start,
+                    endLine: end,
+                    level: 0,
+                    type: 'import',
+                    collapsed: false
+                });
+            }
+            start = -1;
+        }
+    }
+    return regions;
+}
 export function detectFoldRegions(lines, language = 'plaintext', config = {}) {
     const cfg = { ...DEFAULT_CONFIG, ...config };
     const allRegions = [];
@@ -459,6 +492,9 @@ export function detectFoldRegions(lines, language = 'plaintext', config = {}) {
     if (cfg.comments) {
         allRegions.push(...detectCommentFolds(lines, cfg.minLines));
     }
+    if (cfg.imports) {
+        allRegions.push(...detectImportFolds(lines, cfg.minLines));
+    }
     // Sort by start line, then by length (longer regions first for nesting)
     allRegions.sort((a, b) => {
         if (a.startLine !== b.startLine) {

package/package.json

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