@elench/testkit 0.1.64 → 0.1.65

package/node_modules/@swc/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@swc/types/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "@swc/types",
+    "version": "0.1.26",
+    "description": "Typings for the swc project.",
+    "types": "./index.d.ts",
+    "sideEffects": false,
+    "scripts": {
+        "build": "tsc",
+        "prepublishOnly": "yarn build"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/swc-project/swc.git",
+        "directory": "packages/types"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/",
+        "access": "public"
+    },
+    "files": [
+        "*.js",
+        "*.d.ts"
+    ],
+    "keywords": [
+        "swc",
+        "types"
+    ],
+    "author": "강동윤 <kdy1997.dev@gmail.com>",
+    "license": "Apache-2.0",
+    "bugs": {
+        "url": "https://github.com/swc-project/swc/issues"
+    },
+    "homepage": "https://swc.rs",
+    "devDependencies": {
+        "typescript": "^5.2.2"
+    },
+    "dependencies": {
+        "@swc/counter": "^0.1.3"
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.64",
+  "version": "0.1.65",
   "description": "CLI for discovering and running local HTTP, DAL, and Playwright test suites",
   "type": "module",
   "workspaces": [
@@ -51,6 +51,7 @@
     "vendor/"
   ],
   "bundleDependencies": [
+    "@elench/next-analysis",
     "@elench/ts-analysis",
     "@elench/testkit-bridge",
     "@elench/testkit-protocol"
@@ -60,9 +61,10 @@
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "@elench/ts-analysis": "0.1.64",
-    "@elench/testkit-bridge": "0.1.64",
-    "@elench/testkit-protocol": "0.1.64",
+    "@elench/next-analysis": "0.1.65",
+    "@elench/ts-analysis": "0.1.65",
+    "@elench/testkit-bridge": "0.1.65",
+    "@elench/testkit-protocol": "0.1.65",
     "@babel/code-frame": "^7.29.0",
     "@oclif/core": "^4.10.6",
     "esbuild": "^0.25.11",

package/lib/coverage/next-discovery.mjs

@@ -1,205 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { analyzeNextRouteTree } from "./next-static-analysis.mjs";
-import { extractBackendImports, extractExportedFunctions, extractExportedMethodBodies } from "./backend-discovery.mjs";
-import { resolveImportToSourceFile, walkFiles } from "./fs-walk.mjs";
-import { routeFromApiFile, routeFromAppFile } from "./routing.mjs";
-import {
-  dedupeNodes,
-  hasWord,
-  HTTP_METHODS,
-  isServerActionFile,
-  normalizePath,
-  normalizeRoute,
-  pageLabelFromRoute,
-  toApiRequestPath,
-} from "./shared.mjs";
-
-export function discoverPageViews({ serviceName, serviceRoot, nextAppRoot, exclude = [], resolveImportToSourceFile }) {
-  const pageFiles = walkFiles(nextAppRoot, { baseDir: serviceRoot, exclude }).filter(
-    (filePath) => filePath.endsWith("/page.tsx") || filePath.endsWith("/page.ts")
-  );
-  const nodes = [];
-  const edges = [];
-  const pageEntries = [];
-
-  for (const absolutePath of pageFiles) {
-    const relativePath = normalizePath(path.relative(serviceRoot, absolutePath));
-    const route = routeFromAppFile(nextAppRoot, absolutePath);
-    const content = fs.readFileSync(absolutePath, "utf8");
-    const node = {
-      id: `page_view:${serviceName}:${route}`,
-      kind: "page_view",
-      service: serviceName,
-      label: pageLabelFromRoute(route),
-      route,
-      filePath: relativePath,
-    };
-    nodes.push(node);
-    const routeRootFiles = collectRouteRootFiles(nextAppRoot, absolutePath)
-      .map((absoluteRootPath) => ({
-        filePath: normalizePath(path.relative(serviceRoot, absoluteRootPath)),
-        content: fs.readFileSync(absoluteRootPath, "utf8"),
-      }));
-
-    const pageAnalysis = analyzeNextRouteTree({
-      serviceName,
-      serviceRoot,
-      route,
-      rootFiles: routeRootFiles,
-      readSourceFile: (resolvedPath) => {
-        const absoluteResolved = path.join(serviceRoot, resolvedPath);
-        return fs.existsSync(absoluteResolved) ? fs.readFileSync(absoluteResolved, "utf8") : null;
-      },
-      resolveImportPath: (fromFilePath, specifier) => resolveImportToSourceFile(serviceRoot, fromFilePath, specifier),
-      isServerActionFile,
-      normalizeRoute,
-    });
-
-    for (const analysisNode of pageAnalysis.nodes) nodes.push(analysisNode);
-    for (const analysisEdge of pageAnalysis.edges) edges.push(analysisEdge);
-
-    pageEntries.push({
-      node,
-      route,
-      filePath: relativePath,
-      requests: pageAnalysis.requests,
-      serverActionRefs: pageAnalysis.serverActionRefs,
-      surfacesByTargetValue: pageAnalysis.surfacesByTargetValue,
-    });
-  }
-
-  return { nodes, edges, pageEntries };
-}
-
-function collectRouteRootFiles(nextAppRoot, pageAbsolutePath) {
-  const rootFiles = [];
-  let currentDir = path.dirname(pageAbsolutePath);
-  const appRoot = path.resolve(nextAppRoot);
-
-  while (currentDir.startsWith(appRoot)) {
-    const layoutFile = resolveRouteCompanion(currentDir, "layout");
-    if (layoutFile) rootFiles.push(layoutFile);
-    if (currentDir === appRoot) break;
-    currentDir = path.dirname(currentDir);
-  }
-
-  rootFiles.reverse();
-  rootFiles.push(pageAbsolutePath);
-  return [...new Set(rootFiles)];
-}
-
-function resolveRouteCompanion(directoryPath, baseName) {
-  const candidates = [
-    path.join(directoryPath, `${baseName}.tsx`),
-    path.join(directoryPath, `${baseName}.ts`),
-    path.join(directoryPath, `${baseName}.jsx`),
-    path.join(directoryPath, `${baseName}.js`),
-  ];
-  return candidates.find((candidate) => fs.existsSync(candidate)) || null;
-}
-
-export function discoverApiRoutes({ serviceName, serviceRoot, nextAppRoot, exclude = [], resolveImportToSourceFile }) {
-  const routeFiles = walkFiles(path.join(nextAppRoot, "api"), { baseDir: serviceRoot, exclude }).filter(
-    (filePath) => filePath.endsWith("/route.ts") || filePath.endsWith("/route.tsx") || filePath.endsWith("/route.js")
-  );
-  const nodes = [];
-  const edges = [];
-  const routeEntries = [];
-
-  for (const absolutePath of routeFiles) {
-    const filePath = normalizePath(path.relative(serviceRoot, absolutePath));
-    const route = routeFromApiFile(nextAppRoot, absolutePath);
-    const requestPath = toApiRequestPath(route);
-    const content = fs.readFileSync(absolutePath, "utf8");
-    const methodBodies = extractExportedMethodBodies(content, HTTP_METHODS);
-    const backendImports = extractBackendImports({ serviceName, serviceRoot, filePath, content, resolveImportToSourceFile });
-
-    for (const [method, body] of methodBodies) {
-      const node = {
-        id: `api_route:${serviceName}:${method}:${requestPath}`,
-        kind: "api_route",
-        service: serviceName,
-        label: `${method} ${requestPath}`,
-        route,
-        method,
-        path: requestPath,
-        filePath,
-      };
-      nodes.push(node);
-
-      const matchedCapabilities = backendImports.filter((entry) => hasWord(body, entry.importName));
-      for (const capability of matchedCapabilities) {
-        nodes.push(capability.node);
-        edges.push({
-          id: `delegates_to:${node.id}:${capability.node.id}`,
-          kind: "delegates_to",
-          from: node.id,
-          to: capability.node.id,
-          confidence: "high",
-        });
-      }
-
-      routeEntries.push({ node, method, route, requestPath, filePath });
-    }
-  }
-
-  return { nodes: dedupeNodes(nodes), edges, routeEntries };
-}
-
-export function discoverServerActions({ serviceName, serviceRoot, exclude = [], resolveImportToSourceFile }) {
-  const appRoots = [path.join(serviceRoot, "app"), path.join(serviceRoot, "src", "app")].filter((candidate) =>
-    fs.existsSync(candidate)
-  );
-  const nodes = [];
-  const edges = [];
-  const actionEntries = [];
-
-  for (const appRoot of appRoots) {
-    for (const absolutePath of walkFiles(appRoot, { baseDir: serviceRoot, exclude })) {
-      if (!absolutePath.endsWith(".ts") && !absolutePath.endsWith(".tsx")) continue;
-      const content = fs.readFileSync(absolutePath, "utf8");
-      if (!isServerActionFile(content)) continue;
-
-      const relativePath = normalizePath(path.relative(serviceRoot, absolutePath));
-      const backendImports = extractBackendImports({
-        serviceName,
-        serviceRoot,
-        filePath: relativePath,
-        content,
-        resolveImportToSourceFile,
-      });
-      const exportedFunctions = extractExportedFunctions(content);
-
-      for (const exported of exportedFunctions) {
-        const node = {
-          id: `server_action:${serviceName}:${relativePath}#${exported.name}`,
-          kind: "server_action",
-          service: serviceName,
-          label: exported.name,
-          filePath: relativePath,
-        };
-        nodes.push(node);
-        actionEntries.push({
-          node,
-          exportName: exported.name,
-          sourceFile: relativePath,
-        });
-
-        const matchedCapabilities = backendImports.filter((entry) => hasWord(exported.body, entry.importName));
-        for (const capability of matchedCapabilities) {
-          nodes.push(capability.node);
-          edges.push({
-            id: `delegates_to:${node.id}:${capability.node.id}`,
-            kind: "delegates_to",
-            from: node.id,
-            to: capability.node.id,
-            confidence: "high",
-          });
-        }
-      }
-    }
-  }
-
-  return { nodes: dedupeNodes(nodes), edges, actionEntries };
-}