@elench/testkit 0.1.64 → 0.1.66

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

@@ -1,69 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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/jsx.mjs

@@ -1,69 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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;
-}

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

@@ -1,141 +0,0 @@
-import ts from "typescript";
-import { createSourceFile, extractStringLiteral } from "./syntax.mjs";
-
-const HTTP_WRAPPER_METHODS = {
-  getJson: "GET",
-  postJson: "POST",
-  putJson: "PUT",
-  patchJson: "PATCH",
-  deleteJson: "DELETE",
-};
-
-export function extractHttpRequests(content, options = {}) {
-  const filePath = options.filePath || "suite.testkit.ts";
-  const normalizeRoute = options.normalizeRoute || defaultNormalizeRoute;
-  const sourceFile = createSourceFile(filePath, content);
-  const requests = [];
-
-  const visit = (node) => {
-    if (ts.isCallExpression(node)) {
-      const request = resolveHttpRequestCall(node, { normalizeRoute, dynamicSegmentToken: options.dynamicSegmentToken });
-      if (request) requests.push(request);
-    }
-    ts.forEachChild(node, visit);
-  };
-
-  visit(sourceFile);
-  return dedupeRequests(requests);
-}
-
-export function extractPlaywrightVisitedRoutes(content, options = {}) {
-  const filePath = options.filePath || "suite.pw.testkit.ts";
-  const normalizeRoute = options.normalizeRoute || defaultNormalizeRoute;
-  const sourceFile = createSourceFile(filePath, content);
-  const routes = [];
-
-  const visit = (node) => {
-    if (ts.isCallExpression(node)) {
-      const route = resolveGotoRoute(node, { normalizeRoute, dynamicSegmentToken: options.dynamicSegmentToken });
-      if (route) routes.push(route);
-    }
-    ts.forEachChild(node, visit);
-  };
-
-  visit(sourceFile);
-  return [...new Set(routes)];
-}
-
-export function extractRouteLiteral(node, options = {}) {
-  const normalizeRoute = options.normalizeRoute || defaultNormalizeRoute;
-  const literal = extractStringLiteral(node, options);
-  if (!literal) return null;
-  return normalizeRoute(literal.split("?")[0]);
-}
-
-function resolveGotoRoute(callExpression, options) {
-  const callee = callExpression.expression;
-  if (!ts.isPropertyAccessExpression(callee)) return null;
-  if (callee.name.text !== "goto") return null;
-  const pathArg = callExpression.arguments[0];
-  const literal = extractStringLiteral(pathArg, options);
-  if (!literal) return null;
-  if (/^https?:\/\//u.test(literal)) {
-    try {
-      const parsed = new URL(literal);
-      if (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1") {
-        return options.normalizeRoute(parsed.pathname.split("?")[0]);
-      }
-    } catch {
-      return null;
-    }
-    return null;
-  }
-  return options.normalizeRoute(literal.split("?")[0]);
-}
-
-function resolveHttpRequestCall(callExpression, options) {
-  const callee = callExpression.expression;
-  if (ts.isIdentifier(callee)) {
-    if (callee.text === "fetch") {
-      const path = extractRouteLiteral(callExpression.arguments[0], options);
-      if (!path || !path.startsWith("/api/")) return null;
-      return {
-        method: extractFetchMethod(callExpression.arguments[1], options) || "GET",
-        path,
-        confidence: "high",
-      };
-    }
-
-    const method = HTTP_WRAPPER_METHODS[callee.text];
-    if (method) {
-      const path = extractRouteLiteral(callExpression.arguments[0], options);
-      if (!path || !path.startsWith("/api/")) return null;
-      return { method, path, confidence: "high" };
-    }
-
-    if (callee.text === "rawReq") {
-      const methodLiteral = extractStringLiteral(callExpression.arguments[0], options);
-      const path = extractRouteLiteral(callExpression.arguments[1], options);
-      if (!methodLiteral || !path) return null;
-      return { method: methodLiteral.toUpperCase(), path, confidence: "high" };
-    }
-  }
-
-  if (ts.isPropertyAccessExpression(callee) && callee.name.text === "rawReq") {
-    const methodLiteral = extractStringLiteral(callExpression.arguments[0], options);
-    const path = extractRouteLiteral(callExpression.arguments[1], options);
-    if (!methodLiteral || !path) return null;
-    return { method: methodLiteral.toUpperCase(), path, confidence: "high" };
-  }
-
-  return null;
-}
-
-function extractFetchMethod(node, options) {
-  if (!node || !ts.isObjectLiteralExpression(node)) return null;
-  for (const property of node.properties) {
-    if (!ts.isPropertyAssignment(property)) continue;
-    if (property.name.getText() !== "method") continue;
-    const value = extractStringLiteral(property.initializer, options);
-    return value ? value.toUpperCase() : null;
-  }
-  return null;
-}
-
-function dedupeRequests(requests) {
-  const seen = new Set();
-  return requests.filter((entry) => {
-    const key = `${entry.method}:${entry.path}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-
-function defaultNormalizeRoute(value) {
-  const trimmed = String(value || "/").trim();
-  if (!trimmed || trimmed === "/") return "/";
-  const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-  return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/u, "") : withLeadingSlash;
-}
-

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

@@ -1,35 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { DEFAULT_DYNAMIC_SEGMENT_TOKEN } from "./index.mjs";
-import { extractHttpRequests, extractPlaywrightVisitedRoutes } from "./index.mjs";
-
-describe("@elench/ts-analysis requests", () => {
-  it("extracts HTTP requests from fetch, wrappers, and rawReq", () => {
-    const content = `
-      await fetch("/api/projects", { method: "post" });
-      await getJson("/api/projects/123");
-      await rawReq("DELETE", \`/api/projects/\${projectId}\`);
-      await fetch("/not-api/projects");
-    `;
-
-    expect(extractHttpRequests(content, { filePath: "suite.int.testkit.ts" })).toEqual([
-      { method: "POST", path: "/api/projects", confidence: "high" },
-      { method: "GET", path: "/api/projects/123", confidence: "high" },
-      { method: "DELETE", path: `/api/projects/${DEFAULT_DYNAMIC_SEGMENT_TOKEN}`, confidence: "high" },
-    ]);
-  });
-
-  it("extracts Playwright visited routes", () => {
-    const content = `
-      await page.goto("/dashboard");
-      await page.goto(\`/projects/\${id}\`);
-      await this.page.goto("http://localhost:3000/events");
-      await page.goto("https://example.com/external");
-    `;
-
-    expect(extractPlaywrightVisitedRoutes(content, { filePath: "suite.pw.testkit.ts" })).toEqual([
-      "/dashboard",
-      `/projects/${DEFAULT_DYNAMIC_SEGMENT_TOKEN}`,
-      "/events",
-    ]);
-  });
-});

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

@@ -1,53 +0,0 @@
-import fs from "fs";
-import path from "path";
-import ts from "typescript";
-import { defaultCompilerOptions, normalizePath } from "./shared.mjs";
-
-export function resolveImportToSourceFile(serviceRoot, fromFilePath, specifier, compilerOptions = null) {
-  if (!specifier) return null;
-  if (specifier.startsWith(".")) {
-    const fromDirectory = path.dirname(path.join(serviceRoot, fromFilePath));
-    return resolveSourceCandidate(path.resolve(fromDirectory, specifier), serviceRoot);
-  }
-
-  const options = { ...defaultCompilerOptions(serviceRoot), ...(compilerOptions || {}) };
-  const containingFile = path.join(serviceRoot, fromFilePath);
-  const host = ts.sys;
-  const resolved = ts.resolveModuleName(specifier, containingFile, options, host).resolvedModule;
-  if (resolved?.resolvedFileName) {
-    if (resolved.resolvedFileName.endsWith(".d.ts")) return null;
-    return normalizeResolvedFile(serviceRoot, resolved.resolvedFileName);
-  }
-
-  if (specifier.startsWith("@/")) {
-    const fromRoot = resolveSourceCandidate(path.join(serviceRoot, specifier.slice(2)), serviceRoot);
-    if (fromRoot) return fromRoot;
-    return resolveSourceCandidate(path.join(serviceRoot, "src", specifier.slice(2)), serviceRoot);
-  }
-  return null;
-}
-
-export function resolveSourceCandidate(basePath, serviceRoot = null) {
-  const direct = [basePath, `${basePath}.ts`, `${basePath}.tsx`, `${basePath}.js`, `${basePath}.jsx`, `${basePath}.mjs`];
-  for (const candidate of direct) {
-    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return normalizeResolvedFile(serviceRoot, candidate);
-  }
-  const indexed = [
-    path.join(basePath, "index.ts"),
-    path.join(basePath, "index.tsx"),
-    path.join(basePath, "index.js"),
-    path.join(basePath, "index.jsx"),
-    path.join(basePath, "index.mjs"),
-  ];
-  for (const candidate of indexed) {
-    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return normalizeResolvedFile(serviceRoot, candidate);
-  }
-  return null;
-}
-
-function normalizeResolvedFile(serviceRoot, resolvedFileName) {
-  const normalized = normalizePath(resolvedFileName);
-  if (!serviceRoot) return normalized;
-  return normalizePath(path.relative(serviceRoot, normalized));
-}
-

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

@@ -1,32 +0,0 @@
-import path from "path";
-import ts from "typescript";
-
-export const DEFAULT_DYNAMIC_SEGMENT_TOKEN = "__TESTKIT_DYNAMIC_SEGMENT__";
-
-export function normalizePath(filePath) {
-  return String(filePath || "").split(path.sep).join("/");
-}
-
-export function scriptKindForFile(filePath) {
-  const normalized = normalizePath(filePath);
-  if (normalized.endsWith(".tsx")) return ts.ScriptKind.TSX;
-  if (normalized.endsWith(".jsx")) return ts.ScriptKind.JSX;
-  if (normalized.endsWith(".js")) return ts.ScriptKind.JS;
-  return ts.ScriptKind.TS;
-}
-
-export function defaultCompilerOptions(rootDir = process.cwd()) {
-  return {
-    allowJs: true,
-    checkJs: false,
-    jsx: ts.JsxEmit.Preserve,
-    target: ts.ScriptTarget.ESNext,
-    module: ts.ModuleKind.ESNext,
-    moduleResolution: ts.ModuleResolutionKind.Bundler,
-    baseUrl: rootDir,
-    paths: {
-      "@/*": ["./*", "./src/*"],
-    },
-  };
-}
-

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

@@ -1,27 +0,0 @@
-import ts from "typescript";
-import { DEFAULT_DYNAMIC_SEGMENT_TOKEN, scriptKindForFile } from "./shared.mjs";
-
-export function createSourceFile(filePath, content) {
-  return ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, scriptKindForFile(filePath));
-}
-
-export function extractStringLiteral(node, options = {}) {
-  const dynamicSegmentToken = options.dynamicSegmentToken || DEFAULT_DYNAMIC_SEGMENT_TOKEN;
-  if (!node) return null;
-  if (ts.isStringLiteralLike(node)) return node.text;
-  if (ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
-  if (ts.isTemplateExpression(node)) {
-    let value = node.head.text;
-    for (const span of node.templateSpans) {
-      value += dynamicSegmentToken;
-      value += span.literal.text;
-    }
-    return value;
-  }
-  return null;
-}
-
-export function extractLineNumber(node) {
-  return ts.getLineAndCharacterOfPosition(node.getSourceFile(), node.getStart()).line + 1;
-}
-