@mgamil/mapx 0.2.4

package/dist/frameworks/detectors/symfony.js

@@ -0,0 +1,175 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class SymfonyDetector {
+  name = "symfony";
+  language = "php";
+  filePattern = /\.(php|yaml|yml)$/;
+  async detect(projectRoot, files) {
+    const lockPath = join(projectRoot, "symfony.lock");
+    if (existsSync(lockPath)) return true;
+    const composerPath = join(projectRoot, "composer.json");
+    if (existsSync(composerPath)) {
+      try {
+        const pkg = JSON.parse(await readFile(composerPath, "utf-8"));
+        const reqs = { ...pkg.require, ...pkg["require-dev"] };
+        if (reqs && Object.keys(reqs).some((k) => k.startsWith("symfony/"))) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return files.some((f) => f.includes("config/routes.yaml") || f.includes("src/Controller/"));
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    if (filePath.endsWith("routes.yaml") || filePath.endsWith("routes.yml")) {
+      const lines2 = content.split("\n");
+      let currentPath = "";
+      let currentController = "";
+      let currentMethods = [];
+      for (const line of lines2) {
+        if (/^[a-zA-Z0-9_.-]+:/.test(line)) {
+          if (currentPath && currentController) {
+            routes.push(...this.createYamlRouteBindings(currentPath, currentController, currentMethods, filePath, ctx));
+          }
+          currentPath = "";
+          currentController = "";
+          currentMethods = [];
+          continue;
+        }
+        const pathMatch = line.match(/^\s+path:\s*['"]?([^'"]+)['"]?/);
+        if (pathMatch) {
+          currentPath = pathMatch[1];
+          continue;
+        }
+        const controllerMatch = line.match(/^\s+controller:\s*['"]?([^'"]+)['"]?/);
+        if (controllerMatch) {
+          currentController = controllerMatch[1];
+          continue;
+        }
+        const methodsMatch = line.match(/^\s+methods:\s*\[?([^\]]+)\]?/);
+        if (methodsMatch) {
+          currentMethods = methodsMatch[1].split(",").map((m) => m.trim().replace(/['"]/g, "").toUpperCase());
+        }
+      }
+      if (currentPath && currentController) {
+        routes.push(...this.createYamlRouteBindings(currentPath, currentController, currentMethods, filePath, ctx));
+      }
+      return routes;
+    }
+    if (!filePath.endsWith(".php")) {
+      return [];
+    }
+    let classPrefix = "";
+    const classRouteMatch = content.match(/(?:#\[Route|@Route)\s*\(\s*['"]([^'"]+)['"]/);
+    const classDeclMatch = content.match(/\bclass\s+([a-zA-Z0-9_]+)\b/);
+    if (!classDeclMatch) return [];
+    const className = classDeclMatch[1];
+    if (classRouteMatch) {
+      const routeIndex = content.indexOf(classRouteMatch[0]);
+      const classIndex = content.indexOf(classDeclMatch[0]);
+      if (routeIndex !== -1 && routeIndex < classIndex) {
+        classPrefix = classRouteMatch[1];
+      }
+    }
+    const lines = content.split("\n");
+    let pendingRoute = null;
+    for (const line of lines) {
+      const routeAttrMatch = line.match(/(?:#\[Route|@Route)\s*\(\s*['"]([^'"]+)['"]/);
+      if (routeAttrMatch) {
+        const pathVal = routeAttrMatch[1];
+        const methods = [];
+        const methodsMatch = line.match(/methods\s*[=:]\s*\[?([^\]}]+)\]?/);
+        if (methodsMatch) {
+          methods.push(...methodsMatch[1].split(",").map((m) => m.trim().replace(/['"{}]+/g, "").toUpperCase()));
+        }
+        const nameMatch = line.match(/name\s*[=:]\s*['"]([^'"]+)['"]/);
+        const routeName = nameMatch ? nameMatch[1] : void 0;
+        pendingRoute = { path: pathVal, methods, name: routeName };
+        continue;
+      }
+      if (pendingRoute) {
+        const methodDeclMatch = line.match(/\bfunction\s+([a-zA-Z0-9_]+)\s*\(/);
+        if (methodDeclMatch) {
+          const methodName = methodDeclMatch[1];
+          const cleanClassPrefix = classPrefix.replace(/^\/|\/$/g, "");
+          const cleanMethodPath = pendingRoute.path.replace(/^\/|\/$/g, "");
+          const combinedPath = "/" + [cleanClassPrefix, cleanMethodPath].filter(Boolean).join("/");
+          const verbs = pendingRoute.methods.length > 0 ? pendingRoute.methods : ["GET"];
+          for (const verb of verbs) {
+            routes.push({
+              framework: this.name,
+              method: verb,
+              path: combinedPath,
+              handlerFile: filePath,
+              handlerSymbol: `${className}::${methodName}`,
+              metadata: {
+                confidence: "inferred",
+                routeType: "server",
+                routeName: pendingRoute.name
+              }
+            });
+          }
+          pendingRoute = null;
+        }
+      }
+    }
+    return routes;
+  }
+  createYamlRouteBindings(path, controller, methods, filePath, ctx) {
+    const bindings = [];
+    const parts = controller.split("::");
+    const controllerClass = parts[0];
+    const controllerMethod = parts[1] || "default";
+    const symbol = controllerClass.split("\\").pop() || "Controller";
+    let resolvedFile = filePath;
+    const resolvedPath = ctx.resolveSymbolToFile(symbol);
+    if (resolvedPath) {
+      resolvedFile = resolvedPath;
+    }
+    const verbs = methods.length > 0 ? methods : ["ALL"];
+    for (const verb of verbs) {
+      bindings.push({
+        framework: this.name,
+        method: verb,
+        path,
+        handlerFile: resolvedFile,
+        handlerSymbol: `${symbol}::${controllerMethod}`,
+        metadata: {
+          confidence: "inferred",
+          routeType: "server"
+        }
+      });
+    }
+    return bindings;
+  }
+  async extractHooks(filePath, content, ctx) {
+    if (!filePath.endsWith(".php")) {
+      return [];
+    }
+    if (!content.includes("getSubscribedEvents")) {
+      return [];
+    }
+    const hooks = [];
+    const eventRegex = /['"]([^'"]+)['"]\s*=>\s*(?:['"]([^'"]+)['"]|\[\s*['"]([^'"]+)['"])/g;
+    let match;
+    while ((match = eventRegex.exec(content)) !== null) {
+      const eventName = match[1];
+      const handlerSymbol = match[2] || match[3];
+      if (handlerSymbol) {
+        hooks.push({
+          framework: this.name,
+          hookName: eventName,
+          handlerFile: filePath,
+          handlerSymbol,
+          hookType: "event_subscriber"
+        });
+      }
+    }
+    return hooks;
+  }
+}
+export {
+  SymfonyDetector
+};

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

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

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

@@ -0,0 +1,80 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class TanstackRouterDetector {
+  name = "tanstack-router";
+  language = "typescript";
+  filePattern = /\.(js|jsx|ts|tsx)$/;
+  projectFiles = [];
+  async detect(projectRoot, files) {
+    this.projectFiles = 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["@tanstack/react-router"]) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    if (filePath.includes("routes/")) {
+      const routesDirIndex = filePath.indexOf("routes/");
+      let routePart = filePath.substring(routesDirIndex + 7);
+      routePart = routePart.replace(/\.[a-zA-Z0-9]+$/, "");
+      let routePath = "/" + routePart.replace(/\./g, "/");
+      routePath = routePath.replace(/\/index$/, "");
+      if (routePath === "") routePath = "/";
+      routePath = routePath.replace(/\$([a-zA-Z0-9_]+)/g, "{$1}");
+      routes.push({
+        framework: this.name,
+        method: "GET",
+        path: routePath,
+        handlerFile: filePath,
+        handlerSymbol: "Route",
+        metadata: {
+          confidence: "inferred",
+          routeType: "client"
+        }
+      });
+    }
+    const routeRegex = /new\s+Route\s*\(\s*\{([^}]+)\}/g;
+    let match;
+    while ((match = routeRegex.exec(content)) !== null) {
+      const configBody = match[1];
+      const pathMatch = configBody.match(/\bpath\s*:\s*['"]([^'"]+)['"]/);
+      const compMatch = configBody.match(/\bcomponent\s*:\s*([a-zA-Z0-9_]+)/);
+      if (pathMatch) {
+        const routePath = pathMatch[1];
+        const componentSymbol = compMatch ? compMatch[1] : void 0;
+        let resolvedFile = filePath;
+        if (componentSymbol) {
+          const resolvedPath = ctx.resolveSymbolToFile(componentSymbol);
+          if (resolvedPath) {
+            resolvedFile = resolvedPath;
+          }
+        }
+        routes.push({
+          framework: this.name,
+          method: "GET",
+          path: routePath,
+          handlerFile: resolvedFile,
+          handlerSymbol: componentSymbol || "Route",
+          metadata: {
+            confidence: "inferred",
+            routeType: "client"
+          }
+        });
+      }
+    }
+    return routes;
+  }
+}
+export {
+  TanstackRouterDetector
+};

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

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

package/dist/frameworks/detectors/vapor.js

@@ -0,0 +1,52 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class VaporDetector {
+  name = "vapor";
+  language = "swift";
+  filePattern = /\.swift$/;
+  async detect(projectRoot, files) {
+    const pkgSwift = join(projectRoot, "Package.swift");
+    return existsSync(pkgSwift) || files.some((f) => f.endsWith(".swift"));
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    if (!content.includes("import Vapor") && !content.includes("routes(")) {
+      return [];
+    }
+    const routeRegex = /\b[a-zA-Z0-9_]+\.(get|post|put|delete|patch)\s*\(\s*([^)]+)\s*,\s*use\s*:\s*([a-zA-Z0-9_.]+)\s*\)/g;
+    let match;
+    while ((match = routeRegex.exec(content)) !== null) {
+      const verb = match[1].toUpperCase();
+      const rawSegments = match[2];
+      const handlerSymbol = match[3];
+      const segments = rawSegments.split(",").map((s) => s.trim()).map((s) => s.replace(/['"]/g, "")).filter((s) => s !== "");
+      const mappedSegments = segments.map((seg) => {
+        if (seg.startsWith(":")) {
+          return `{${seg.substring(1)}}`;
+        }
+        return seg;
+      });
+      const pathVal = "/" + mappedSegments.join("/");
+      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"
+        }
+      });
+    }
+    return routes;
+  }
+}
+export {
+  VaporDetector
+};

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

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

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

@@ -0,0 +1,237 @@
+import { readFile } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { existsSync } from "node:fs";
+class VueRouterDetector {
+  name = "vue-router";
+  language = "typescript";
+  filePattern = /\.(js|ts|vue)$/;
+  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["vue-router"] || deps["vue"])) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    if (!content.includes("VueRouter") && !content.includes("createRouter") && !content.includes("routes") && !content.includes("routerMap") && !content.includes("routeMap")) {
+      return [];
+    }
+    let index = 0;
+    while (true) {
+      const match = content.substring(index).match(/\b[a-zA-Z0-9_]*(?:routes|Routes|routesList|routerMap|routeMap|RouteMap)(?:\s*:[^=]+)?\s*[=:]\s*\[/);
+      if (!match) break;
+      const startOfArray = index + match.index + match[0].length - 1;
+      const arrayObj = getBracketedContent(content, startOfArray);
+      if (!arrayObj) {
+        index = startOfArray + 1;
+        continue;
+      }
+      const parsedRoutes = this.parseRoutesArray(arrayObj.content, filePath, ctx);
+      routes.push(...parsedRoutes);
+      index = arrayObj.endIndex;
+    }
+    return routes;
+  }
+  parseRoutesArray(content, filePath, ctx, prefixParts = []) {
+    const routes = [];
+    let index = 0;
+    while (index < content.length) {
+      const startOfBrace = content.indexOf("{", index);
+      if (startOfBrace === -1) break;
+      const obj = getBracedContent(content, startOfBrace);
+      if (!obj) {
+        index = startOfBrace + 1;
+        continue;
+      }
+      const objBody = obj.content;
+      const pathMatch = objBody.match(/\bpath\s*:\s*['"`]([^'"`]*)['"`]/);
+      const pathVal = pathMatch ? pathMatch[1] : "";
+      const componentsList = [];
+      const compMatch = objBody.match(/\bcomponent\s*:\s*([a-zA-Z0-9_]+)\b(?!\s*=>)/);
+      if (compMatch && compMatch[1] !== "import" && compMatch[1] !== "require") {
+        const componentSymbol = compMatch[1];
+        let resolvedFile = filePath;
+        const resolvedPath = ctx.resolveSymbolToFile(componentSymbol);
+        if (resolvedPath) {
+          resolvedFile = resolvedPath;
+        }
+        componentsList.push({ symbol: componentSymbol, file: resolvedFile });
+      }
+      const importMatches = objBody.matchAll(/import\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g);
+      for (const impMatch of importMatches) {
+        const importPath = impMatch[1];
+        let resolvedFile = filePath;
+        if (importPath.startsWith(".")) {
+          resolvedFile = join(dirname(filePath), importPath);
+        }
+        const symbol = importPath.split("/").pop()?.replace(/\.[a-zA-Z0-9]+$/, "") || "Component";
+        componentsList.push({ symbol, file: resolvedFile });
+      }
+      const requireMatches = objBody.matchAll(/require\s*\(\s*(?:\[\s*)?['"`]([^'"`]+)['"`]/g);
+      for (const reqMatch of requireMatches) {
+        const importPath = reqMatch[1];
+        let resolvedFile = filePath;
+        if (importPath.startsWith(".")) {
+          resolvedFile = join(dirname(filePath), importPath);
+        }
+        const symbol = importPath.split("/").pop()?.replace(/\.[a-zA-Z0-9]+$/, "") || "Component";
+        componentsList.push({ symbol, file: resolvedFile });
+      }
+      const componentsMatch = objBody.match(/\bcomponents\s*:\s*\{([^}]+)\}/);
+      if (componentsMatch) {
+        const compsBody = componentsMatch[1];
+        const symbolRegex = /\b[a-zA-Z0-9_]+\s*:\s*([a-zA-Z0-9_]+)\b(?!\s*=>)/g;
+        let match;
+        while ((match = symbolRegex.exec(compsBody)) !== null) {
+          const compSym = match[1];
+          if (compSym !== "import" && compSym !== "require") {
+            let resolvedFile = filePath;
+            const resolvedPath = ctx.resolveSymbolToFile(compSym);
+            if (resolvedPath) {
+              resolvedFile = resolvedPath;
+            }
+            componentsList.push({ symbol: compSym, file: resolvedFile });
+          }
+        }
+      }
+      const cleanParentPrefix = prefixParts.map((p) => p.replace(/^\/|\/$/g, "")).filter(Boolean);
+      const cleanPath = pathVal.replace(/^\/|\/$/g, "");
+      const fullPath = "/" + [...cleanParentPrefix, cleanPath].filter(Boolean).join("/");
+      if (componentsList.length > 0) {
+        for (const comp of componentsList) {
+          routes.push({
+            framework: this.name,
+            method: "GET",
+            path: fullPath,
+            handlerFile: comp.file,
+            handlerSymbol: comp.symbol,
+            metadata: {
+              confidence: "inferred",
+              routeType: "client"
+            }
+          });
+        }
+      } else if (objBody.includes("children")) {
+        routes.push({
+          framework: this.name,
+          method: "GET",
+          path: fullPath,
+          handlerFile: filePath,
+          handlerSymbol: "Component",
+          metadata: {
+            confidence: "inferred",
+            routeType: "client"
+          }
+        });
+      }
+      const childrenMatch = objBody.match(/\bchildren\s*:\s*\[/);
+      if (childrenMatch) {
+        const childrenStart = objBody.indexOf("children") + childrenMatch[0].length - 1;
+        const childrenArray = getBracketedContent(objBody, childrenStart);
+        if (childrenArray) {
+          const childRoutes = this.parseRoutesArray(childrenArray.content, filePath, ctx, [...prefixParts, pathVal]);
+          routes.push(...childRoutes);
+        }
+      }
+      index = obj.endIndex;
+    }
+    return routes;
+  }
+}
+function getBracketedContent(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;
+}
+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 {
+  VueRouterDetector
+};

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

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