@elench/testkit 0.1.63 → 0.1.65

package/node_modules/@elench/testkit-protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-protocol",
-  "version": "0.1.63",
+  "version": "0.1.65",
   "description": "Shared browser protocol for testkit bridge and extension consumers",
   "type": "module",
   "main": "./src/index.mjs",

package/node_modules/@elench/ts-analysis/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@elench/ts-analysis",
+  "version": "0.1.65",
+  "description": "TypeScript compiler-backed source analysis primitives for Erench tools",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.mjs",
+    "./package.json": "./package.json"
+  }
+}

package/node_modules/@elench/ts-analysis/src/callables.mjs

@@ -0,0 +1,135 @@
+import ts from "typescript";
+import { extractStringLiteral } from "./syntax.mjs";
+
+export function collectImports(sourceFile, options) {
+  const imports = new Map();
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement) || !statement.importClause) continue;
+    const specifier = extractStringLiteral(statement.moduleSpecifier);
+    if (!specifier) continue;
+    const resolvedFilePath = options.resolveImportPath(specifier);
+    const sourceContent = resolvedFilePath ? options.readSourceFile(resolvedFilePath) : null;
+    const serverActionImport = Boolean(sourceContent && options.isServerActionFile(sourceContent));
+
+    if (statement.importClause.name) {
+      imports.set(statement.importClause.name.text, {
+        importedName: "default",
+        specifier,
+        resolvedFilePath,
+        isServerAction: serverActionImport,
+      });
+    }
+
+    const bindings = statement.importClause.namedBindings;
+    if (!bindings || !ts.isNamedImports(bindings)) continue;
+    for (const element of bindings.elements) {
+      const localName = element.name.text;
+      const importedName = element.propertyName?.text || localName;
+      imports.set(localName, {
+        importedName,
+        specifier,
+        resolvedFilePath,
+        isServerAction: serverActionImport,
+      });
+    }
+  }
+  return imports;
+}
+
+export function collectTopLevelFunctions(sourceFile) {
+  const functions = new Map();
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement) && statement.name) {
+      functions.set(statement.name.text, statement);
+      continue;
+    }
+
+    if (!ts.isVariableStatement(statement)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+      if (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer)) {
+        functions.set(declaration.name.text, declaration.initializer);
+      }
+    }
+  }
+  return functions;
+}
+
+export function collectExportedCallables(sourceFile, topLevelFunctions) {
+  const exports = new Map();
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement) && statement.name && hasExportModifier(statement.modifiers)) {
+      exports.set(statement.name.text, statement);
+      continue;
+    }
+
+    if (!ts.isVariableStatement(statement) || !hasExportModifier(statement.modifiers)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+      if (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer)) {
+        exports.set(declaration.name.text, declaration.initializer);
+      } else if (ts.isIdentifier(declaration.initializer)) {
+        const referenced = topLevelFunctions.get(declaration.initializer.text);
+        if (referenced) exports.set(declaration.name.text, referenced);
+      }
+    }
+  }
+  return exports;
+}
+
+export function collectScopeLocalFunctions(node) {
+  const functions = new Map();
+  const callableBody = "body" in node ? node.body : null;
+  if (!callableBody) return functions;
+
+  const visit = (child) => {
+    if (ts.isFunctionDeclaration(child) && child.name) {
+      functions.set(child.name.text, child);
+      if (child !== callableBody) return;
+    }
+
+    if (
+      child !== callableBody &&
+      (ts.isArrowFunction(child) || ts.isFunctionExpression(child))
+    ) {
+      return;
+    }
+
+    if (ts.isVariableDeclaration(child) && ts.isIdentifier(child.name) && child.initializer) {
+      if (ts.isArrowFunction(child.initializer) || ts.isFunctionExpression(child.initializer)) {
+        functions.set(child.name.text, child.initializer);
+      }
+    }
+
+    ts.forEachChild(child, visit);
+  };
+
+  visit(callableBody);
+  return functions;
+}
+
+export function findDefaultExportCallable(sourceFile, localFunctions) {
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement) && hasDefaultModifier(statement.modifiers)) {
+      return statement;
+    }
+
+    if (ts.isExportAssignment(statement)) {
+      if (ts.isIdentifier(statement.expression)) {
+        return localFunctions.get(statement.expression.text) || null;
+      }
+      if (ts.isArrowFunction(statement.expression) || ts.isFunctionExpression(statement.expression)) {
+        return statement.expression;
+      }
+    }
+  }
+  return null;
+}
+
+function hasExportModifier(modifiers) {
+  return Boolean(modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
+}
+
+function hasDefaultModifier(modifiers) {
+  return Boolean(modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword));
+}

package/node_modules/@elench/ts-analysis/src/callables.test.mjs

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import {
+  collectExportedCallables,
+  collectImports,
+  collectScopeLocalFunctions,
+  collectTopLevelFunctions,
+  createSourceFile,
+  findDefaultExportCallable,
+} from "./index.mjs";
+
+describe("@elench/ts-analysis callables", () => {
+  it("collects top-level, exported, and scope-local callables", () => {
+    const content = `
+      import { saveSettings as save } from "./actions";
+
+      function helper() {}
+      const localArrow = () => {};
+
+      export function namedExport() {}
+      export const exportedArrow = () => {};
+
+      export default function Page() {
+        function nestedDecl() {}
+        const nestedArrow = () => {};
+        return <button onClick={nestedArrow}>Save</button>;
+      }
+    `;
+    const sourceFile = createSourceFile("page.tsx", content);
+    const topLevel = collectTopLevelFunctions(sourceFile);
+    const exported = collectExportedCallables(sourceFile, topLevel);
+    const defaultExport = findDefaultExportCallable(sourceFile, topLevel);
+    const locals = collectScopeLocalFunctions(defaultExport);
+
+    expect([...topLevel.keys()]).toEqual(["helper", "localArrow", "namedExport", "exportedArrow", "Page"]);
+    expect([...exported.keys()]).toEqual(["namedExport", "exportedArrow", "Page"]);
+    expect([...locals.keys()]).toEqual(["nestedDecl", "nestedArrow"]);
+  });
+
+  it("collects imports with server action metadata", () => {
+    const sourceFile = createSourceFile(
+      "page.tsx",
+      `import action, { saveSettings as save } from "./actions"; import { Button } from "@/components/ui/button";`
+    );
+    const imports = collectImports(sourceFile, {
+      readSourceFile: (filePath) => (filePath === "src/app/actions.ts" ? '"use server";\nexport async function saveSettings() {}' : "export const Button = () => null;"),
+      resolveImportPath: (specifier) =>
+        specifier === "./actions" ? "src/app/actions.ts" : specifier === "@/components/ui/button" ? "src/components/ui/button.tsx" : null,
+      isServerActionFile: (content) => content.includes('"use server"'),
+    });
+
+    expect(imports.get("action")).toMatchObject({ importedName: "default", isServerAction: true });
+    expect(imports.get("save")).toMatchObject({ importedName: "saveSettings", isServerAction: true });
+    expect(imports.get("Button")).toMatchObject({ importedName: "Button", isServerAction: false });
+  });
+});

package/node_modules/@elench/ts-analysis/src/exports.mjs

@@ -0,0 +1,69 @@
+import ts from "typescript";
+import { createSourceFile } from "./syntax.mjs";
+
+export function extractExportedMethodBodies(content, methods, filePath = "route.ts") {
+  const bodies = [];
+  for (const method of methods) {
+    const body = extractExportedFunctionBody(content, method, filePath);
+    if (body) bodies.push([method, body]);
+  }
+  return bodies;
+}
+
+export function extractExportedFunctions(content, filePath = "module.ts") {
+  const sourceFile = createSourceFile(filePath, content);
+  const exported = [];
+  for (const statement of sourceFile.statements) {
+    if (!ts.isFunctionDeclaration(statement) || !statement.name || !hasExportModifier(statement.modifiers) || !statement.body) {
+      continue;
+    }
+    exported.push({
+      name: statement.name.text,
+      body: bodyText(sourceFile, statement.body),
+    });
+  }
+  return exported;
+}
+
+export function extractExportedFunctionBody(content, exportName, filePath = "module.ts") {
+  const sourceFile = createSourceFile(filePath, content);
+  for (const statement of sourceFile.statements) {
+    if (!ts.isFunctionDeclaration(statement) || !statement.name || statement.name.text !== exportName) continue;
+    if (!hasExportModifier(statement.modifiers) || !statement.body) return null;
+    return bodyText(sourceFile, statement.body);
+  }
+  return null;
+}
+
+export function readBalancedBlock(content, startIndex) {
+  let depth = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let inTemplate = false;
+
+  for (let index = startIndex; index < content.length; index += 1) {
+    const char = content[index];
+    const previous = content[index - 1];
+    if (char === "'" && !inDouble && !inTemplate && previous !== "\\") inSingle = !inSingle;
+    if (char === '"' && !inSingle && !inTemplate && previous !== "\\") inDouble = !inDouble;
+    if (char === "`" && !inSingle && !inDouble && previous !== "\\") inTemplate = !inTemplate;
+    if (inSingle || inDouble || inTemplate) continue;
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return content.slice(startIndex, index + 1);
+      }
+    }
+  }
+  return null;
+}
+
+function hasExportModifier(modifiers) {
+  return Boolean(modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
+}
+
+function bodyText(sourceFile, bodyNode) {
+  return sourceFile.text.slice(bodyNode.getStart(sourceFile), bodyNode.end);
+}
+

package/node_modules/@elench/ts-analysis/src/exports.test.mjs

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import {
+  extractExportedFunctionBody,
+  extractExportedFunctions,
+  extractExportedMethodBodies,
+  readBalancedBlock,
+} from "./index.mjs";
+
+describe("@elench/ts-analysis exports", () => {
+  it("extracts exported method bodies via AST", () => {
+    const content = `
+      export async function GET() {
+        const template = "{not a block}";
+        return template;
+      }
+
+      export async function POST() {
+        return { ok: true };
+      }
+    `;
+
+    expect(extractExportedMethodBodies(content, ["GET", "POST"], "route.ts")).toEqual([
+      ["GET", expect.stringContaining('"{not a block}"')],
+      ["POST", expect.stringContaining("{ ok: true }")],
+    ]);
+  });
+
+  it("extracts exported named functions and bodies", () => {
+    const content = `
+      export async function saveSettings() {
+        return updateSettings();
+      }
+
+      export function listSettings() {
+        return [];
+      }
+    `;
+
+    expect(extractExportedFunctions(content, "actions.ts")).toEqual([
+      { name: "saveSettings", body: expect.stringContaining("updateSettings") },
+      { name: "listSettings", body: expect.stringContaining("return [];") },
+    ]);
+    expect(extractExportedFunctionBody(content, "saveSettings", "actions.ts")).toContain("updateSettings");
+  });
+
+  it("reads a balanced block from a brace offset", () => {
+    const content = "before { const tpl = `{nested}`; return tpl; } after";
+    expect(readBalancedBlock(content, content.indexOf("{"))).toBe("{ const tpl = `{nested}`; return tpl; }");
+  });
+});

package/node_modules/@elench/ts-analysis/src/index.mjs

@@ -0,0 +1,14 @@
+export { DEFAULT_DYNAMIC_SEGMENT_TOKEN, normalizePath } from "./shared.mjs";
+export { createAnalysisProject, findNearestTsConfig, loadTsConfig } from "./project.mjs";
+export { resolveImportToSourceFile, resolveSourceCandidate } from "./resolution.mjs";
+export {
+  collectExportedCallables,
+  collectImports,
+  collectScopeLocalFunctions,
+  collectTopLevelFunctions,
+  findDefaultExportCallable,
+} from "./callables.mjs";
+export { collectJsxAttributes, extractJsxLabel, flattenJsxText, walkJsx } from "./jsx.mjs";
+export { extractExportedFunctionBody, extractExportedFunctions, extractExportedMethodBodies, readBalancedBlock } from "./exports.mjs";
+export { extractHttpRequests, extractPlaywrightVisitedRoutes, extractRouteLiteral } from "./requests.mjs";
+export { createSourceFile, extractLineNumber, extractStringLiteral } from "./syntax.mjs";

package/node_modules/@elench/ts-analysis/src/jsx.mjs

@@ -0,0 +1,69 @@
+import ts from "typescript";
+
+export function walkJsx(sourceFile, visitor) {
+  const visit = (node, formContext = null) => {
+    let nextFormContext = formContext;
+    if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
+      nextFormContext = visitor(node, formContext);
+    }
+
+    if (ts.isJsxElement(node)) {
+      for (const child of node.children) visit(child, nextFormContext);
+      return;
+    }
+
+    ts.forEachChild(node, (child) => visit(child, nextFormContext));
+  };
+
+  visit(sourceFile, null);
+}
+
+export function collectJsxAttributes(openingElement) {
+  const attributes = {};
+  for (const property of openingElement.attributes.properties) {
+    if (!ts.isJsxAttribute(property)) continue;
+    const name = property.name.text;
+    if (!property.initializer) {
+      attributes[name] = { stringValue: "true", expression: null };
+      continue;
+    }
+    if (ts.isStringLiteral(property.initializer)) {
+      attributes[name] = { stringValue: property.initializer.text, expression: null };
+      continue;
+    }
+    if (ts.isJsxExpression(property.initializer)) {
+      attributes[name] = {
+        stringValue: property.initializer.expression && ts.isStringLiteralLike(property.initializer.expression)
+          ? property.initializer.expression.text
+          : null,
+        expression: property.initializer.expression || null,
+      };
+    }
+  }
+  return attributes;
+}
+
+export function flattenJsxText(children) {
+  let text = "";
+  for (const child of children) {
+    if (ts.isJsxText(child)) {
+      text += child.getText().replace(/\s+/gu, " ");
+    } else if (ts.isJsxExpression(child) && child.expression && ts.isStringLiteralLike(child.expression)) {
+      text += child.expression.text;
+    } else if (ts.isJsxElement(child)) {
+      text += flattenJsxText(child.children);
+    }
+  }
+  return text;
+}
+
+export function extractJsxLabel(node, attributes) {
+  const ariaLabel = attributes["aria-label"]?.stringValue || attributes.title?.stringValue || null;
+  if (ariaLabel) return ariaLabel;
+  if (ts.isJsxElement(node)) {
+    const text = flattenJsxText(node.children).trim();
+    if (text) return text;
+  }
+  return null;
+}
+

package/node_modules/@elench/ts-analysis/src/jsx.test.mjs

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { collectJsxAttributes, createSourceFile, extractJsxLabel, walkJsx } from "./index.mjs";
+
+describe("@elench/ts-analysis JSX helpers", () => {
+  it("walks JSX and extracts attributes and labels", () => {
+    const sourceFile = createSourceFile(
+      "page.tsx",
+      `
+        export default function Page() {
+          return (
+            <form action={submit}>
+              <button data-testid="save-button" aria-label="Save settings">Save</button>
+            </form>
+          );
+        }
+      `
+    );
+    const tags = [];
+
+    walkJsx(sourceFile, (node) => {
+      const opening = "openingElement" in node ? node.openingElement : node;
+      const attributes = collectJsxAttributes(opening);
+      tags.push({
+        tag: opening.tagName.getText(),
+        label: extractJsxLabel(node, attributes),
+        attributes,
+      });
+      return null;
+    });
+
+    expect(tags).toHaveLength(2);
+    expect(tags[0].tag).toBe("form");
+    expect(tags[0].attributes.action.stringValue).toBeNull();
+    expect(tags[0].attributes.action.expression.getText()).toBe("submit");
+    expect(tags[1]).toMatchObject({
+      tag: "button",
+      label: "Save settings",
+      attributes: {
+        "data-testid": { stringValue: "save-button", expression: null },
+      },
+    });
+  });
+});

package/node_modules/@elench/ts-analysis/src/project.mjs

@@ -0,0 +1,100 @@
+import fs from "fs";
+import path from "path";
+import ts from "typescript";
+import { defaultCompilerOptions, normalizePath } from "./shared.mjs";
+import { resolveImportToSourceFile } from "./resolution.mjs";
+
+export function findNearestTsConfig(startDir) {
+  return ts.findConfigFile(startDir, ts.sys.fileExists, "tsconfig.json") || null;
+}
+
+export function loadTsConfig(tsconfigPath) {
+  const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+  if (configFile.error) {
+    return {
+      tsconfigPath,
+      rootDir: path.dirname(tsconfigPath),
+      fileNames: [],
+      options: defaultCompilerOptions(path.dirname(tsconfigPath)),
+      errors: [configFile.error],
+    };
+  }
+
+  const parsed = ts.parseJsonConfigFileContent(
+    configFile.config,
+    ts.sys,
+    path.dirname(tsconfigPath),
+    defaultCompilerOptions(path.dirname(tsconfigPath)),
+    tsconfigPath
+  );
+
+  return {
+    tsconfigPath,
+    rootDir: path.dirname(tsconfigPath),
+    fileNames: parsed.fileNames.map(normalizePath),
+    options: parsed.options,
+    errors: parsed.errors || [],
+  };
+}
+
+export function createAnalysisProject({ rootDir, tsconfigPath = null } = {}) {
+  const resolvedRoot = path.resolve(rootDir || process.cwd());
+  const resolvedConfigPath = tsconfigPath ? path.resolve(tsconfigPath) : findNearestTsConfig(resolvedRoot);
+  const config = resolvedConfigPath
+    ? loadTsConfig(resolvedConfigPath)
+    : {
+        tsconfigPath: null,
+        rootDir: resolvedRoot,
+        fileNames: listProjectFiles(resolvedRoot),
+        options: defaultCompilerOptions(resolvedRoot),
+        errors: [],
+      };
+
+  const program = ts.createProgram(config.fileNames, config.options);
+  const checker = program.getTypeChecker();
+  const diagnostics = [...config.errors, ...ts.getPreEmitDiagnostics(program)];
+
+  return {
+    rootDir: config.rootDir,
+    tsconfigPath: config.tsconfigPath,
+    program,
+    checker,
+    compilerOptions: config.options,
+    diagnostics,
+    getSourceFiles() {
+      return program.getSourceFiles().filter((file) => !file.isDeclarationFile);
+    },
+    getSourceFile(filePath) {
+      return program.getSourceFile(path.isAbsolute(filePath) ? filePath : path.join(config.rootDir, filePath)) || null;
+    },
+    readSourceFile(filePath) {
+      const sourceFile = this.getSourceFile(filePath);
+      return sourceFile ? sourceFile.text : null;
+    },
+    resolveImport(fromFilePath, specifier) {
+      return resolveImportToSourceFile(config.rootDir, normalizePath(fromFilePath), specifier, config.options);
+    },
+  };
+}
+
+function listProjectFiles(rootDir) {
+  const results = [];
+  const queue = [rootDir];
+  while (queue.length > 0) {
+    const current = queue.pop();
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      if (entry.isSymbolicLink()) continue;
+      const absolutePath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === ".next" || entry.name === ".git") continue;
+        queue.push(absolutePath);
+        continue;
+      }
+      if (/\.(ts|tsx|js|jsx|mjs)$/u.test(entry.name)) {
+        results.push(normalizePath(absolutePath));
+      }
+    }
+  }
+  return results.sort((left, right) => left.localeCompare(right));
+}
+

package/node_modules/@elench/ts-analysis/src/project.test.mjs

@@ -0,0 +1,54 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, describe, expect, it } from "vitest";
+import { createAnalysisProject, findNearestTsConfig, loadTsConfig } from "./index.mjs";
+
+const cleanups = [];
+
+afterEach(() => {
+  while (cleanups.length > 0) {
+    cleanups.pop()();
+  }
+});
+
+describe("@elench/ts-analysis project", () => {
+  it("loads tsconfig-backed projects and resolves imports", () => {
+    const rootDir = createProject({
+      "tsconfig.json": JSON.stringify({
+        compilerOptions: {
+          baseUrl: ".",
+          paths: {
+            "@/*": ["src/*"],
+          },
+          jsx: "preserve",
+          module: "esnext",
+          target: "es2022",
+        },
+        include: ["src/**/*"],
+      }),
+      "src/app/page.tsx": `import { save } from "@/server/actions"; export default function Page() { return <button onClick={save}>Save</button>; }`,
+      "src/server/actions.ts": `export async function save() { return true; }`,
+    });
+
+    const tsconfigPath = findNearestTsConfig(path.join(rootDir, "src", "app"));
+    const config = loadTsConfig(tsconfigPath);
+    const project = createAnalysisProject({ rootDir });
+
+    expect(config.fileNames.some((filePath) => filePath.endsWith("src/app/page.tsx"))).toBe(true);
+    expect(project.resolveImport("src/app/page.tsx", "@/server/actions")).toBe("src/server/actions.ts");
+    expect(project.readSourceFile("src/server/actions.ts")).toContain("export async function save");
+    expect(project.diagnostics).toEqual([]);
+  });
+});
+
+function createProject(files) {
+  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-ts-analysis-"));
+  cleanups.push(() => fs.rmSync(rootDir, { recursive: true, force: true }));
+  for (const [relativePath, content] of Object.entries(files)) {
+    const absolutePath = path.join(rootDir, relativePath);
+    fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+    fs.writeFileSync(absolutePath, content);
+  }
+  return rootDir;
+}