@mgamil/mapx 0.2.4

package/dist/frameworks/detectors/nextjs.js

@@ -0,0 +1,118 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class NextJSDetector {
+  name = "nextjs";
+  language = "typescript";
+  filePattern = /\.(js|jsx|ts|tsx)$/;
+  async detect(projectRoot, files) {
+    const packageJsonPath = join(projectRoot, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps && deps.next) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    const pathNormalized = filePath.replace(/\\/g, "/");
+    if (pathNormalized.includes("pages/")) {
+      const pagesIndex = pathNormalized.indexOf("pages/");
+      let routePart = pathNormalized.substring(pagesIndex + 6);
+      routePart = routePart.replace(/\.[a-zA-Z0-9]+$/, "");
+      let routePath = "/" + routePart;
+      routePath = routePath.replace(/\/index$/, "");
+      if (routePath === "") routePath = "/";
+      routePath = routePath.replace(/\[([a-zA-Z0-9_]+)\]/g, "{$1}");
+      const isApi = routePath.startsWith("/api/");
+      routes.push({
+        framework: this.name,
+        method: isApi ? "ALL" : "GET",
+        path: routePath,
+        handlerFile: filePath,
+        handlerSymbol: "default",
+        metadata: {
+          confidence: "inferred",
+          routeType: isApi ? "server" : "client"
+        }
+      });
+    }
+    if (pathNormalized.endsWith("/page.tsx") || pathNormalized.endsWith("/page.jsx")) {
+      const appIndex = pathNormalized.indexOf("app/");
+      if (appIndex !== -1) {
+        let routePart = pathNormalized.substring(appIndex + 4);
+        routePart = routePart.replace(/\/page\.[a-zA-Z0-9]+$/, "");
+        const segments = routePart.split("/").filter((seg) => !seg.startsWith("(") || !seg.endsWith(")"));
+        let routePath = "/" + segments.join("/");
+        if (routePath === "") routePath = "/";
+        routePath = routePath.replace(/\[([a-zA-Z0-9_]+)\]/g, "{$1}");
+        routes.push({
+          framework: this.name,
+          method: "GET",
+          path: routePath,
+          handlerFile: filePath,
+          handlerSymbol: "default",
+          metadata: {
+            confidence: "inferred",
+            routeType: "client"
+          }
+        });
+      }
+    }
+    if (pathNormalized.endsWith("/route.ts") || pathNormalized.endsWith("/route.js")) {
+      const appIndex = pathNormalized.indexOf("app/");
+      if (appIndex !== -1) {
+        let routePart = pathNormalized.substring(appIndex + 4);
+        routePart = routePart.replace(/\/route\.[a-zA-Z0-9]+$/, "");
+        const segments = routePart.split("/").filter((seg) => !seg.startsWith("(") || !seg.endsWith(")"));
+        let routePath = "/" + segments.join("/");
+        if (routePath === "") routePath = "/";
+        routePath = routePath.replace(/\[([a-zA-Z0-9_]+)\]/g, "{$1}");
+        const verbRegex = /export\s+(?:async\s+)?function\s+(GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD)\b/g;
+        let match;
+        while ((match = verbRegex.exec(content)) !== null) {
+          const verb = match[1];
+          routes.push({
+            framework: this.name,
+            method: verb,
+            path: routePath,
+            handlerFile: filePath,
+            handlerSymbol: verb,
+            metadata: {
+              confidence: "inferred",
+              routeType: "server"
+            }
+          });
+        }
+      }
+    }
+    if (content.includes("'use server'") || content.includes('"use server"')) {
+      const actionRegex = /export\s+(?:async\s+)?function\s+([a-zA-Z0-9_]+)\b/g;
+      let match;
+      while ((match = actionRegex.exec(content)) !== null) {
+        const actionName = match[1];
+        routes.push({
+          framework: this.name,
+          method: "POST",
+          path: `/action/${actionName}`,
+          handlerFile: filePath,
+          handlerSymbol: actionName,
+          metadata: {
+            confidence: "inferred",
+            routeType: "server"
+          }
+        });
+      }
+    }
+    return routes;
+  }
+}
+export {
+  NextJSDetector
+};

package/dist/frameworks/detectors/rails.d.ts

@@ -0,0 +1,12 @@
+import { FrameworkDetector, ScanContext, RouteBinding } from '../../types.js';
+
+declare class RailsDetector implements FrameworkDetector {
+    readonly name = "rails";
+    readonly language = "ruby";
+    readonly filePattern: RegExp;
+    detect(projectRoot: string, files: string[]): Promise<boolean>;
+    extractRoutes(filePath: string, content: string, ctx: ScanContext): Promise<RouteBinding[]>;
+    private createRouteBinding;
+}
+
+export { RailsDetector };

package/dist/frameworks/detectors/rails.js

@@ -0,0 +1,76 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class RailsDetector {
+  name = "rails";
+  language = "ruby";
+  filePattern = /(routes\.rb|Gemfile)$/;
+  async detect(projectRoot, files) {
+    const gemfilePath = join(projectRoot, "Gemfile");
+    if (existsSync(gemfilePath)) {
+      const content = await readFile(gemfilePath, "utf-8");
+      if (content.includes("rails")) return true;
+    }
+    return files.some((f) => f.endsWith("routes.rb"));
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    if (!filePath.endsWith("routes.rb")) {
+      return [];
+    }
+    const routeRegex = /\b(get|post|put|patch|delete)\s+['"]([^'"]+)['"]\s*,\s*to:\s*['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = routeRegex.exec(content)) !== null) {
+      const verb = match[1].toUpperCase();
+      let pathVal = match[2];
+      const controllerAction = match[3];
+      pathVal = pathVal.replace(/:([a-zA-Z0-9_]+)/g, "{$1}");
+      routes.push(this.createRouteBinding(verb, pathVal, controllerAction, filePath, ctx));
+    }
+    const resourcesRegex = /\bresources\s+:([a-zA-Z0-9_]+)/g;
+    while ((match = resourcesRegex.exec(content)) !== null) {
+      const resourceName = match[1];
+      const controllerPrefix = resourceName.charAt(0).toUpperCase() + resourceName.slice(1);
+      const controllerClass = `${controllerPrefix}Controller`;
+      const crudEndpoints = [
+        { verb: "GET", path: `/${resourceName}`, action: "index" },
+        { verb: "GET", path: `/${resourceName}/new`, action: "new" },
+        { verb: "POST", path: `/${resourceName}`, action: "create" },
+        { verb: "GET", path: `/${resourceName}/{id}`, action: "show" },
+        { verb: "GET", path: `/${resourceName}/{id}/edit`, action: "edit" },
+        { verb: "PUT", path: `/${resourceName}/{id}`, action: "update" },
+        { verb: "PATCH", path: `/${resourceName}/{id}`, action: "update" },
+        { verb: "DELETE", path: `/${resourceName}/{id}`, action: "destroy" }
+      ];
+      for (const endpoint of crudEndpoints) {
+        routes.push(this.createRouteBinding(endpoint.verb, endpoint.path, `${resourceName}#${endpoint.action}`, filePath, ctx));
+      }
+    }
+    return routes;
+  }
+  createRouteBinding(verb, path, controllerAction, filePath, ctx) {
+    const parts = controllerAction.split("#");
+    const controller = parts[0];
+    const action = parts[1] || "index";
+    const controllerClassName = controller.charAt(0).toUpperCase() + controller.slice(1) + "Controller";
+    let resolvedFile = filePath;
+    const resolvedPath = ctx.resolveSymbolToFile(controllerClassName);
+    if (resolvedPath) {
+      resolvedFile = resolvedPath;
+    }
+    return {
+      framework: this.name,
+      method: verb,
+      path,
+      handlerFile: resolvedFile,
+      handlerSymbol: `${controllerClassName}#${action}`,
+      metadata: {
+        confidence: "inferred",
+        routeType: "server"
+      }
+    };
+  }
+}
+export {
+  RailsDetector
+};

package/dist/frameworks/detectors/react-router.d.ts

@@ -0,0 +1,11 @@
+import { FrameworkDetector, ScanContext, RouteBinding } from '../../types.js';
+
+declare class ReactRouterDetector implements FrameworkDetector {
+    readonly name = "react-router";
+    readonly language = "typescript";
+    readonly filePattern: RegExp;
+    detect(projectRoot: string, files: string[]): Promise<boolean>;
+    extractRoutes(filePath: string, content: string, ctx: ScanContext): Promise<RouteBinding[]>;
+}
+
+export { ReactRouterDetector };

package/dist/frameworks/detectors/react-router.js

@@ -0,0 +1,115 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class ReactRouterDetector {
+  name = "react-router";
+  language = "typescript";
+  filePattern = /\.(js|jsx|ts|tsx)$/;
+  async detect(projectRoot, files) {
+    const packageJsonPath = join(projectRoot, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps && (deps["react-router"] || deps["react-router-dom"])) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    if (!content.includes("Route") && !content.includes("createBrowserRouter")) {
+      return [];
+    }
+    const tagRegex = /<\/?Route\b|path=['"]([^'"]*)['"]|element=\{\s*<\s*([a-zA-Z0-9_]+)/g;
+    let match;
+    const pathStack = [];
+    let currentPath = null;
+    let currentElement = null;
+    let inOpeningTag = false;
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (line.includes("<Route")) {
+        const pathMatch = line.match(/\bpath=['"]([^'"]*)['"]/);
+        const elementMatch = line.match(/\belement=\{\s*<\s*([a-zA-Z0-9_]+)/);
+        const pathSeg = pathMatch ? pathMatch[1] : "";
+        const element = elementMatch ? elementMatch[1] : null;
+        if (line.trim().endsWith("/>")) {
+          const fullPath = "/" + [...pathStack, pathSeg].map((p) => p.replace(/^\/|\/$/g, "")).filter(Boolean).join("/");
+          if (element) {
+            let resolvedFile = filePath;
+            const resolvedPath = ctx.resolveSymbolToFile(element);
+            if (resolvedPath) {
+              resolvedFile = resolvedPath;
+            }
+            routes.push({
+              framework: this.name,
+              method: "GET",
+              path: fullPath,
+              handlerFile: resolvedFile,
+              handlerSymbol: element,
+              metadata: {
+                confidence: "inferred",
+                routeType: "client"
+              }
+            });
+          }
+        } else {
+          pathStack.push(pathSeg);
+          if (element) {
+            const fullPath = "/" + pathStack.map((p) => p.replace(/^\/|\/$/g, "")).filter(Boolean).join("/");
+            let resolvedFile = filePath;
+            const resolvedPath = ctx.resolveSymbolToFile(element);
+            if (resolvedPath) {
+              resolvedFile = resolvedPath;
+            }
+            routes.push({
+              framework: this.name,
+              method: "GET",
+              path: fullPath,
+              handlerFile: resolvedFile,
+              handlerSymbol: element,
+              metadata: {
+                confidence: "inferred",
+                routeType: "client"
+              }
+            });
+          }
+        }
+      } else if (line.includes("</Route>")) {
+        pathStack.pop();
+      }
+    }
+    const createRouterRegex = /createBrowserRouter\s*\(/;
+    if (createRouterRegex.test(content)) {
+      const configRegex = /path\s*:\s*['"]([^'"]+)['"]\s*,\s*element\s*:\s*<\s*([a-zA-Z0-9_]+)/g;
+      while ((match = configRegex.exec(content)) !== null) {
+        const routePath = match[1];
+        const element = match[2];
+        let resolvedFile = filePath;
+        const resolvedPath = ctx.resolveSymbolToFile(element);
+        if (resolvedPath) {
+          resolvedFile = resolvedPath;
+        }
+        routes.push({
+          framework: this.name,
+          method: "GET",
+          path: routePath,
+          handlerFile: resolvedFile,
+          handlerSymbol: element,
+          metadata: {
+            confidence: "inferred",
+            routeType: "client"
+          }
+        });
+      }
+    }
+    return routes;
+  }
+}
+export {
+  ReactRouterDetector
+};

package/dist/frameworks/detectors/rust.d.ts

@@ -0,0 +1,11 @@
+import { FrameworkDetector, ScanContext, RouteBinding } from '../../types.js';
+
+declare class RustDetector implements FrameworkDetector {
+    readonly name = "rust-web";
+    readonly language = "rust";
+    readonly filePattern: RegExp;
+    detect(projectRoot: string, files: string[]): Promise<boolean>;
+    extractRoutes(filePath: string, content: string, ctx: ScanContext): Promise<RouteBinding[]>;
+}
+
+export { RustDetector };

package/dist/frameworks/detectors/rust.js

@@ -0,0 +1,59 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class RustDetector {
+  name = "rust-web";
+  language = "rust";
+  filePattern = /\.rs$/;
+  async detect(projectRoot, files) {
+    const cargoPath = join(projectRoot, "Cargo.toml");
+    return existsSync(cargoPath) || files.some((f) => f.endsWith(".rs"));
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    const axumRegex = /\.route\s*\(\s*['"]([^'"]+)['"]\s*,\s*([a-z0-9_]+)\s*\(\s*([a-zA-Z0-9_:]+)\s*\)\s*\)/g;
+    let match;
+    while ((match = axumRegex.exec(content)) !== null) {
+      const pathVal = match[1];
+      const verb = match[2].toUpperCase();
+      const handlerSymbol = match[3];
+      let resolvedFile = filePath;
+      const resolvedPath = ctx.resolveSymbolToFile(handlerSymbol);
+      if (resolvedPath) {
+        resolvedFile = resolvedPath;
+      }
+      routes.push({
+        framework: this.name,
+        method: verb,
+        path: pathVal,
+        handlerFile: resolvedFile,
+        handlerSymbol,
+        metadata: {
+          confidence: "inferred",
+          routeType: "server"
+        }
+      });
+    }
+    const attrRegex = /#\[(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]\s*\)\]\s*(?:pub\s+)?(?:async\s+)?fn\s+([a-zA-Z0-9_]+)\b/g;
+    while ((match = attrRegex.exec(content)) !== null) {
+      const verb = match[1].toUpperCase();
+      let pathVal = match[2];
+      const handlerSymbol = match[3];
+      pathVal = pathVal.replace(/<([a-zA-Z0-9_]+)>/g, "{$1}");
+      routes.push({
+        framework: this.name,
+        method: verb,
+        path: pathVal,
+        handlerFile: filePath,
+        handlerSymbol,
+        metadata: {
+          confidence: "inferred",
+          routeType: "server"
+        }
+      });
+    }
+    return routes;
+  }
+}
+export {
+  RustDetector
+};

package/dist/frameworks/detectors/spring.d.ts

@@ -0,0 +1,11 @@
+import { FrameworkDetector, ScanContext, RouteBinding } from '../../types.js';
+
+declare class SpringDetector implements FrameworkDetector {
+    readonly name = "spring";
+    readonly language = "java";
+    readonly filePattern: RegExp;
+    detect(projectRoot: string, files: string[]): Promise<boolean>;
+    extractRoutes(filePath: string, content: string, ctx: ScanContext): Promise<RouteBinding[]>;
+}
+
+export { SpringDetector };

package/dist/frameworks/detectors/spring.js

@@ -0,0 +1,56 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class SpringDetector {
+  name = "spring";
+  language = "java";
+  filePattern = /\.(java|kt)$/;
+  async detect(projectRoot, files) {
+    const hasPom = existsSync(join(projectRoot, "pom.xml"));
+    const hasGradle = existsSync(join(projectRoot, "build.gradle"));
+    if (hasPom || hasGradle) return true;
+    return files.some((f) => f.endsWith(".java") || f.endsWith(".kt"));
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    if (!content.includes("Controller") && !content.includes("RequestMapping")) {
+      return [];
+    }
+    let classPrefix = "";
+    const classMappingMatch = content.match(/@RequestMapping\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+    if (classMappingMatch) {
+      classPrefix = classMappingMatch[1];
+    } else {
+      const restControllerMatch = content.match(/@RestController\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+      if (restControllerMatch) {
+        classPrefix = restControllerMatch[1];
+      }
+    }
+    const classDeclMatch = content.match(/\bclass\s+([a-zA-Z0-9_]+)\b/);
+    const className = classDeclMatch ? classDeclMatch[1] : "Controller";
+    const mappingRegex = /@(Get|Post|Put|Delete|Patch)Mapping(?:\s*\(\s*['"]([^'"]+)['"]\s*\))?[^({]*?\b([a-zA-Z0-9_]+)\s*\(/g;
+    let match;
+    while ((match = mappingRegex.exec(content)) !== null) {
+      const mappingType = match[1].toUpperCase();
+      const mappingPath = match[2] || "";
+      const methodName = match[3];
+      const cleanClassPrefix = classPrefix.replace(/^\/|\/$/g, "");
+      const cleanMethodPath = mappingPath.replace(/^\/|\/$/g, "");
+      const combinedPath = "/" + [cleanClassPrefix, cleanMethodPath].filter(Boolean).join("/");
+      routes.push({
+        framework: this.name,
+        method: mappingType,
+        path: combinedPath,
+        handlerFile: filePath,
+        handlerSymbol: `${className}.${methodName}`,
+        metadata: {
+          confidence: "inferred",
+          routeType: "server"
+        }
+      });
+    }
+    return routes;
+  }
+}
+export {
+  SpringDetector
+};

package/dist/frameworks/detectors/sveltekit.d.ts

@@ -0,0 +1,11 @@
+import { FrameworkDetector, ScanContext, RouteBinding } from '../../types.js';
+
+declare class SvelteKitDetector implements FrameworkDetector {
+    readonly name = "sveltekit";
+    readonly language = "typescript";
+    readonly filePattern: RegExp;
+    detect(projectRoot: string, files: string[]): Promise<boolean>;
+    extractRoutes(filePath: string, content: string, ctx: ScanContext): Promise<RouteBinding[]>;
+}
+
+export { SvelteKitDetector };

package/dist/frameworks/detectors/sveltekit.js

@@ -0,0 +1,154 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class SvelteKitDetector {
+  name = "sveltekit";
+  language = "typescript";
+  filePattern = /\.(svelte|ts|js)$/;
+  async detect(projectRoot, files) {
+    const svelteConfigPath = join(projectRoot, "svelte.config.js");
+    if (existsSync(svelteConfigPath)) {
+      return true;
+    }
+    const packageJsonPath = join(projectRoot, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps && (deps["@sveltejs/kit"] || deps["svelte"])) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    const pathNormalized = filePath.replace(/\\/g, "/");
+    if (pathNormalized.includes("src/routes/")) {
+      const routesIndex = pathNormalized.indexOf("src/routes/");
+      let routePart = pathNormalized.substring(routesIndex + 11);
+      if (routePart.endsWith("+page.svelte")) {
+        routePart = routePart.replace(/\/\+page\.svelte$/, "");
+        let routePath = "/" + routePart;
+        if (routePath === "/+") routePath = "/";
+        if (routePath === "") routePath = "/";
+        routePath = routePath.replace(/\[([a-zA-Z0-9_]+)\]/g, "{$1}");
+        routes.push({
+          framework: this.name,
+          method: "GET",
+          path: routePath,
+          handlerFile: filePath,
+          handlerSymbol: "default",
+          metadata: {
+            confidence: "inferred",
+            routeType: "client"
+          }
+        });
+      }
+      if (routePart.endsWith("+server.ts") || routePart.endsWith("+server.js")) {
+        routePart = routePart.replace(/\/\+server\.[a-zA-Z0-9]+$/, "");
+        let routePath = "/" + routePart;
+        if (routePath === "/+") routePath = "/";
+        if (routePath === "") routePath = "/";
+        routePath = routePath.replace(/\[([a-zA-Z0-9_]+)\]/g, "{$1}");
+        const verbRegex = /export\s+(?:const|async\s+function)\s+(GET|POST|PUT|DELETE|PATCH)\b/g;
+        let match;
+        while ((match = verbRegex.exec(content)) !== null) {
+          const verb = match[1];
+          routes.push({
+            framework: this.name,
+            method: verb,
+            path: routePath,
+            handlerFile: filePath,
+            handlerSymbol: verb,
+            metadata: {
+              confidence: "inferred",
+              routeType: "server"
+            }
+          });
+        }
+      }
+      if (routePart.endsWith("+page.server.ts") || routePart.endsWith("+page.server.js")) {
+        routePart = routePart.replace(/\/\+page\.server\.[a-zA-Z0-9]+$/, "");
+        let routePath = "/" + routePart;
+        if (routePath === "/+") routePath = "/";
+        if (routePath === "") routePath = "/";
+        routePath = routePath.replace(/\[([a-zA-Z0-9_]+)\]/g, "{$1}");
+        const actionsIndex = content.indexOf("export const actions");
+        if (actionsIndex !== -1) {
+          const braceStart = content.indexOf("{", actionsIndex);
+          if (braceStart !== -1) {
+            const bodyObj = getBracedContent(content, braceStart);
+            if (bodyObj) {
+              const actionKeysRegex = /\b([a-zA-Z0-9_]+)\s*:/g;
+              let keyMatch;
+              while ((keyMatch = actionKeysRegex.exec(bodyObj.content)) !== null) {
+                const actionName = keyMatch[1];
+                routes.push({
+                  framework: this.name,
+                  method: "POST",
+                  path: actionName === "default" ? routePath : `${routePath}?/${actionName}`,
+                  handlerFile: filePath,
+                  handlerSymbol: `actions.${actionName}`,
+                  metadata: {
+                    confidence: "inferred",
+                    routeType: "server"
+                  }
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+    return routes;
+  }
+}
+function getBracedContent(str, startIndex) {
+  let depth = 0;
+  let inString = false;
+  let stringChar = "";
+  let escape = false;
+  for (let i = startIndex; i < str.length; i++) {
+    const char = str[i];
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (char === "\\") {
+      escape = true;
+      continue;
+    }
+    if (inString) {
+      if (char === stringChar) {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      inString = true;
+      stringChar = char;
+      continue;
+    }
+    if (char === "{") {
+      depth++;
+      if (depth === 1) {
+        startIndex = i + 1;
+      }
+    } else if (char === "}") {
+      depth--;
+      if (depth === 0) {
+        return {
+          content: str.substring(startIndex, i),
+          endIndex: i + 1
+        };
+      }
+    }
+  }
+  return null;
+}
+export {
+  SvelteKitDetector
+};

package/dist/frameworks/detectors/symfony.d.ts

@@ -0,0 +1,13 @@
+import { FrameworkDetector, ScanContext, RouteBinding, HookBinding } from '../../types.js';
+
+declare class SymfonyDetector implements FrameworkDetector {
+    readonly name = "symfony";
+    readonly language = "php";
+    readonly filePattern: RegExp;
+    detect(projectRoot: string, files: string[]): Promise<boolean>;
+    extractRoutes(filePath: string, content: string, ctx: ScanContext): Promise<RouteBinding[]>;
+    private createYamlRouteBindings;
+    extractHooks(filePath: string, content: string, ctx: ScanContext): Promise<HookBinding[]>;
+}
+
+export { SymfonyDetector };