septum 0.1.5 → 0.1.6

package/src/core/parser/boundary-tracker.ts

@@ -286,3 +286,148 @@ export function calculatePythonNesting(
 
   return maxDepth;
 }
+
+/**
+ * Replaces the contents of comments and string/template literals with spaces while
+ * preserving exact character offsets, outer quote delimiters, and line breaks.
+ */
+export function blankCommentsAndStrings(
+  content: string,
+  options?: { hashComments?: boolean }
+): string {
+  const hashComments = options?.hashComments ?? false;
+  const out = content.split("");
+  const len = out.length;
+
+  let i = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let inTemplate = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+
+  while (i < len) {
+    const ch = out[i];
+    const next = i + 1 < len ? out[i + 1] : "";
+
+    if (inLineComment) {
+      if (ch === "\n") {
+        inLineComment = false;
+      } else if (ch !== "\r") {
+        out[i] = " ";
+      }
+      i++;
+      continue;
+    }
+
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        out[i] = " ";
+        out[i + 1] = " ";
+        inBlockComment = false;
+        i += 2;
+        continue;
+      }
+      if (ch !== "\n" && ch !== "\r") {
+        out[i] = " ";
+      }
+      i++;
+      continue;
+    }
+
+    if (inSingle) {
+      if (ch === "\\" && i + 1 < len) {
+        if (out[i] !== "\n" && out[i] !== "\r") out[i] = " ";
+        if (out[i + 1] !== "\n" && out[i + 1] !== "\r") out[i + 1] = " ";
+        i += 2;
+        continue;
+      }
+      if (ch === "'") {
+        inSingle = false;
+      } else if (ch !== "\n" && ch !== "\r") {
+        out[i] = " ";
+      }
+      i++;
+      continue;
+    }
+
+    if (inDouble) {
+      if (ch === "\\" && i + 1 < len) {
+        if (out[i] !== "\n" && out[i] !== "\r") out[i] = " ";
+        if (out[i + 1] !== "\n" && out[i + 1] !== "\r") out[i + 1] = " ";
+        i += 2;
+        continue;
+      }
+      if (ch === '"') {
+        inDouble = false;
+      } else if (ch !== "\n" && ch !== "\r") {
+        out[i] = " ";
+      }
+      i++;
+      continue;
+    }
+
+    if (inTemplate) {
+      if (ch === "\\" && i + 1 < len) {
+        if (out[i] !== "\n" && out[i] !== "\r") out[i] = " ";
+        if (out[i + 1] !== "\n" && out[i + 1] !== "\r") out[i + 1] = " ";
+        i += 2;
+        continue;
+      }
+      if (ch === "`") {
+        inTemplate = false;
+      } else if (ch !== "\n" && ch !== "\r") {
+        out[i] = " ";
+      }
+      i++;
+      continue;
+    }
+
+    // Normal code state
+    if (ch === "/" && next === "/") {
+      out[i] = " ";
+      out[i + 1] = " ";
+      inLineComment = true;
+      i += 2;
+      continue;
+    }
+
+    if (ch === "/" && next === "*") {
+      out[i] = " ";
+      out[i + 1] = " ";
+      inBlockComment = true;
+      i += 2;
+      continue;
+    }
+
+    if (hashComments && ch === "#") {
+      out[i] = " ";
+      inLineComment = true;
+      i++;
+      continue;
+    }
+
+    if (ch === "'") {
+      inSingle = true;
+      i++;
+      continue;
+    }
+
+    if (ch === '"') {
+      inDouble = true;
+      i++;
+      continue;
+    }
+
+    if (ch === "`") {
+      inTemplate = true;
+      i++;
+      continue;
+    }
+
+    i++;
+  }
+
+  return out.join("");
+}
+

package/src/core/parser/extractors/frontend.ts

@@ -4,8 +4,11 @@ import type {
   ParsedFileAST,
 } from "../../../types/index.ts";
 import type { CodeExtractor } from "./base.ts";
+import { TypeScriptExtractor } from "./typescript.ts";
 
 export class FrontendExtractor implements CodeExtractor {
+  private readonly tsExtractor = new TypeScriptExtractor();
+
   public canHandle(filePath: string): boolean {
     return /\.(vue|astro|svelte)$/i.test(filePath);
   }
@@ -19,22 +22,21 @@ export class FrontendExtractor implements CodeExtractor {
     const isSvelte = /\.svelte$/i.test(filePath);
 
     if (isVue) {
-      this.extractVue(content, symbols, dependencies);
+      await this.extractVue(content, symbols, dependencies);
     } else if (isAstro) {
-      this.extractAstro(content, symbols, dependencies);
+      await this.extractAstro(content, symbols, dependencies);
     } else if (isSvelte) {
-      this.extractSvelte(content, symbols, dependencies);
+      await this.extractSvelte(content, symbols, dependencies);
     }
 
     return { symbols, dependencies };
   }
 
-  private extractVue(
+  private async extractVue(
     content: string,
     symbols: ExtractedSymbol[],
     dependencies: ExtractedDependency[]
-  ): void {
-    // Match <script> and <script setup> blocks
+  ): Promise<void> {
     const scriptRegex = /<script(\s+[^>]*?)?>([\s\S]*?)<\/script>/gi;
     let match: RegExpExecArray | null;
 
@@ -44,64 +46,61 @@ export class FrontendExtractor implements CodeExtractor {
       const scriptBody = match[2];
       const isSetup = /\bsetup\b/i.test(attributes);
 
-      // Calculate start line of the script body
-      const beforeMatch = content.slice(0, match.index);
       const tagOpenMatch = fullMatch.match(/<script(\s+[^>]*?)?>/i);
       const tagOpenLen = tagOpenMatch ? tagOpenMatch[0].length : 0;
       const scriptStartOffset = match.index + tagOpenLen;
       const startLine = content.slice(0, scriptStartOffset).split("\n").length;
 
-      // Extract symbols and dependencies from this script block
-      this.extractScriptContent(scriptBody, startLine, symbols, dependencies);
+      await this.extractScriptContent(scriptBody, startLine, symbols, dependencies);
 
       if (isSetup) {
+        const scriptLines = scriptBody.split("\n").length;
         symbols.push({
           name: "<script setup>",
           kind: "method",
           signature: "script setup",
           visibility: "public",
           line_start: startLine,
-          line_end: startLine + scriptBody.split("\n").length,
-          line_count: scriptBody.split("\n").length,
+          line_end: startLine + scriptLines - 1,
+          line_count: Math.max(1, scriptLines),
         });
       }
     }
 
-    // Vue defineProps / defineEmits detection
     const definePropsMatch = content.match(/defineProps\s*<([^>]+)>/);
     if (definePropsMatch) {
       const line = content.slice(0, content.indexOf(definePropsMatch[0])).split("\n").length;
+      const propLines = definePropsMatch[0].split("\n").length;
       symbols.push({
         name: "Props",
         kind: "interface",
         signature: `defineProps<${definePropsMatch[1]}>`,
         visibility: "public",
         line_start: line,
-        line_end: line,
-        line_count: 1,
+        line_end: line + propLines - 1,
+        line_count: Math.max(1, propLines),
       });
     }
   }
 
-  private extractAstro(
+  private async extractAstro(
     content: string,
     symbols: ExtractedSymbol[],
     dependencies: ExtractedDependency[]
-  ): void {
-    // Astro frontmatter is between the first --- and the second ---
+  ): Promise<void> {
     const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
     if (frontmatterMatch) {
       const scriptBody = frontmatterMatch[1];
-      const startLine = 2; // Line 1 is '---'
-      this.extractScriptContent(scriptBody, startLine, symbols, dependencies);
+      const startLine = 2;
+      await this.extractScriptContent(scriptBody, startLine, symbols, dependencies);
     }
   }
 
-  private extractSvelte(
+  private async extractSvelte(
     content: string,
     symbols: ExtractedSymbol[],
     dependencies: ExtractedDependency[]
-  ): void {
+  ): Promise<void> {
     const scriptRegex = /<script(\s+[^>]*?)?>([\s\S]*?)<\/script>/gi;
     let match: RegExpExecArray | null;
 
@@ -113,82 +112,36 @@ export class FrontendExtractor implements CodeExtractor {
       const scriptStartOffset = match.index + tagOpenLen;
       const startLine = content.slice(0, scriptStartOffset).split("\n").length;
 
-      this.extractScriptContent(scriptBody, startLine, symbols, dependencies);
+      await this.extractScriptContent(scriptBody, startLine, symbols, dependencies);
     }
   }
 
-  private extractScriptContent(
+  private async extractScriptContent(
     scriptContent: string,
-    lineOffset: number,
+    startLine: number,
     symbols: ExtractedSymbol[],
     dependencies: ExtractedDependency[]
-  ): void {
-    const lines = scriptContent.split("\n");
-
-    // 1. Extract Imports
-    const importRegex = /(?:import\s+(?:(?:[\w*\s{},]+)\s+from\s+)?['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      let match: RegExpExecArray | null;
-      while ((match = importRegex.exec(line)) !== null) {
-        const target = match[1] || match[2];
-        if (target) {
-          const isExternal = !target.startsWith(".") && !target.startsWith("/");
-          dependencies.push({
-            target,
-            statement: line.trim(),
-            line_number: lineOffset + i,
-            is_external: isExternal,
-          });
-        }
-      }
+  ): Promise<void> {
+    const parsed = await this.tsExtractor.extract("component-script.ts", scriptContent);
+    const delta = Math.max(0, startLine - 1);
+
+    for (const dep of parsed.dependencies) {
+      dependencies.push({
+        ...dep,
+        line_number: dep.line_number + delta,
+      });
     }
 
-    // 2. Extract Functions / Methods / Classes / Components
-    const funcRegex = /(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+([a-zA-Z0-9_]+)/g;
-    const constFuncRegex = /(?:export\s+)?const\s+([a-zA-Z0-9_]+)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[a-zA-Z0-9_]+)\s*=>/g;
-    const classRegex = /(?:export\s+)?class\s+([a-zA-Z0-9_]+)/g;
-
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const currentLineNum = lineOffset + i;
-
-      let m: RegExpExecArray | null;
-      while ((m = funcRegex.exec(line)) !== null) {
-        symbols.push({
-          name: m[1],
-          kind: "function",
-          signature: line.trim(),
-          visibility: line.includes("export") ? "public" : "private",
-          line_start: currentLineNum,
-          line_end: currentLineNum,
-          line_count: 1,
-        });
-      }
-
-      while ((m = constFuncRegex.exec(line)) !== null) {
-        symbols.push({
-          name: m[1],
-          kind: "function",
-          signature: line.trim(),
-          visibility: line.includes("export") ? "public" : "private",
-          line_start: currentLineNum,
-          line_end: currentLineNum,
-          line_count: 1,
-        });
-      }
-
-      while ((m = classRegex.exec(line)) !== null) {
-        symbols.push({
-          name: m[1],
-          kind: "class",
-          signature: line.trim(),
-          visibility: line.includes("export") ? "public" : "private",
-          line_start: currentLineNum,
-          line_end: currentLineNum,
-          line_count: 1,
-        });
-      }
+    for (const sym of parsed.symbols) {
+      const shiftedStart = sym.line_start + delta;
+      const shiftedEnd = Math.max(shiftedStart, sym.line_end + delta);
+      symbols.push({
+        ...sym,
+        line_start: shiftedStart,
+        line_end: shiftedEnd,
+        line_count: Math.max(1, shiftedEnd - shiftedStart + 1),
+      });
     }
   }
 }
+