@archest/vitest 1.0.0 → 1.0.1

package/src/core/Project.ts

@@ -1,171 +0,0 @@
-import * as ts from 'typescript';
-import * as path from 'path';
-import { FileLocator, FileQueryOptions } from './FileLocator';
-import { ClassLocator, ClassQueryOptions } from './ClassLocator';
-import { LayeredArchitectureBuilder } from './LayerLocator';
-import { FunctionLocator, FunctionQueryOptions } from './FunctionLocator';
-import { PropertyLocator, PropertyQueryOptions } from './PropertyLocator';
-import { SliceLocator } from './SliceLocator';
-
-export class Project {
-  private program: ts.Program;
-  private typeChecker: ts.TypeChecker;
-
-  constructor(options: { tsConfigFilePath?: string } = {}) {
-    let compilerOptions: ts.CompilerOptions = {};
-    const configPath = options.tsConfigFilePath || ts.findConfigFile(
-      process.cwd(),
-      ts.sys.fileExists,
-      'tsconfig.json'
-    );
-
-    if (configPath) {
-      const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-      const parsedCommandLine = ts.parseJsonConfigFileContent(
-        configFile.config,
-        ts.sys,
-        path.dirname(configPath),
-        undefined,
-        configPath,
-        undefined,
-        [
-          { extension: '.vue', isMixedContent: true, scriptKind: ts.ScriptKind.TS },
-          { extension: '.svelte', isMixedContent: true, scriptKind: ts.ScriptKind.TS }
-        ]
-      );
-      compilerOptions = parsedCommandLine.options;
-
-      const host = ts.createCompilerHost(compilerOptions);
-      const originalGetSourceFile = host.getSourceFile;
-
-      let vueCompiler: any;
-      try {
-        vueCompiler = require('@vue/compiler-sfc');
-      } catch (e) {
-        // Not a Vue project
-      }
-
-      host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
-        if (fileName.endsWith('.vue')) {
-          const content = ts.sys.readFile(fileName);
-          if (content) {
-            let scriptContent = '';
-            if (vueCompiler) {
-              const parsed = vueCompiler.parse(content);
-              const script = parsed.descriptor.script;
-              const scriptSetup = parsed.descriptor.scriptSetup;
-              if (script) scriptContent += script.content + '\n';
-              if (scriptSetup) scriptContent += scriptSetup.content + '\n';
-            } else {
-              // Fallback for Svelte or if compiler-sfc is missing (fragile but works for simple cases)
-              const match = content.match(/<script[^>]*>(.*?)<\/script>/s);
-              if (match) scriptContent = match[1];
-            }
-            return ts.createSourceFile(fileName, scriptContent, languageVersion, true, ts.ScriptKind.TS);
-          }
-        }
-        
-        if (fileName.endsWith('.svelte')) {
-          const content = ts.sys.readFile(fileName);
-          if (content) {
-            let scriptContent = '';
-            const match = content.match(/<script[^>]*>(.*?)<\/script>/s);
-            if (match) scriptContent = match[1];
-            return ts.createSourceFile(fileName, scriptContent, languageVersion, true, ts.ScriptKind.TS);
-          }
-        }
-
-        return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
-      };
-
-      this.program = ts.createProgram({
-        rootNames: parsedCommandLine.fileNames,
-        options: compilerOptions,
-        host: host
-      });
-    } else {
-      throw new Error("Could not find tsconfig.json");
-    }
-
-    this.typeChecker = this.program.getTypeChecker();
-  }
-
-  getFiles(options?: FileQueryOptions) {
-    const sourceFiles = this.program.getSourceFiles().filter(
-      sf => !sf.isDeclarationFile && !sf.fileName.includes('node_modules')
-    );
-    return new FileLocator(sourceFiles, this.program, options);
-  }
-
-  getClasses(options?: ClassQueryOptions) {
-    const sourceFiles = this.program.getSourceFiles().filter(
-      sf => !sf.isDeclarationFile && !sf.fileName.includes('node_modules')
-    );
-    
-    const allClasses: ts.ClassDeclaration[] = [];
-    for (const sf of sourceFiles) {
-      const visit = (node: ts.Node) => {
-        if (ts.isClassDeclaration(node)) {
-          allClasses.push(node);
-        }
-        ts.forEachChild(node, visit);
-      };
-      visit(sf);
-    }
-    return new ClassLocator(allClasses, this.program, options);
-  }
-
-  layeredArchitecture() {
-    const sourceFiles = this.program.getSourceFiles().filter(
-      sf => !sf.isDeclarationFile && !sf.fileName.includes('node_modules')
-    );
-    return new LayeredArchitectureBuilder(sourceFiles, this.program);
-  }
-
-  getFunctions(options?: FunctionQueryOptions) {
-    const sourceFiles = this.program.getSourceFiles().filter(
-      sf => !sf.isDeclarationFile && !sf.fileName.includes('node_modules')
-    );
-    
-    const allFunctions: ts.FunctionLikeDeclaration[] = [];
-    for (const sf of sourceFiles) {
-      const visit = (node: ts.Node) => {
-        if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isArrowFunction(node)) {
-          allFunctions.push(node);
-        }
-        ts.forEachChild(node, visit);
-      };
-      visit(sf);
-    }
-    return new FunctionLocator(allFunctions, this.program, options);
-  }
-
-  getProperties(options?: PropertyQueryOptions) {
-    const sourceFiles = this.program.getSourceFiles().filter(
-      sf => !sf.isDeclarationFile && !sf.fileName.includes('node_modules')
-    );
-    
-    const allProperties: ts.PropertyDeclaration[] = [];
-    for (const sf of sourceFiles) {
-      const visit = (node: ts.Node) => {
-        if (ts.isPropertyDeclaration(node)) {
-          allProperties.push(node);
-        }
-        ts.forEachChild(node, visit);
-      };
-      visit(sf);
-    }
-    return new PropertyLocator(allProperties, this.program, options);
-  }
-
-  getSlices(pattern: string) {
-    const sourceFiles = this.program.getSourceFiles().filter(
-      sf => !sf.isDeclarationFile && !sf.fileName.includes('node_modules')
-    );
-    return new SliceLocator(sourceFiles, this.program, pattern);
-  }
-}
-
-export function parseProject(tsConfigFilePath?: string): Project {
-  return new Project({ tsConfigFilePath });
-}

package/src/core/PropertyLocator.ts

@@ -1,50 +0,0 @@
-import * as ts from 'typescript';
-import { RuleResult } from './types';
-
-export interface PropertyQueryOptions {
-  inFolder?: string;
-  matchNamePattern?: string | RegExp;
-}
-
-export class PropertyLocator {
-  public readonly properties: ts.PropertyDeclaration[];
-
-  constructor(properties: ts.PropertyDeclaration[], private program: ts.Program, options?: PropertyQueryOptions) {
-    let filtered = properties;
-
-    if (options?.inFolder) {
-      filtered = filtered.filter((p) => {
-        const sourceFile = p.getSourceFile();
-        return sourceFile.fileName.includes(`/${options.inFolder}/`) || sourceFile.fileName.includes(`\\${options.inFolder}\\`);
-      });
-    }
-
-    if (options?.matchNamePattern) {
-      const regex = typeof options.matchNamePattern === 'string' ? new RegExp(options.matchNamePattern) : options.matchNamePattern;
-      filtered = filtered.filter((p) => {
-        return ts.isIdentifier(p.name) && regex.test(p.name.text);
-      });
-    }
-
-    this.properties = filtered;
-  }
-
-  checkBeReadonly(isNot: boolean): RuleResult {
-    const violations: string[] = [];
-    for (const p of this.properties) {
-      const name = ts.isIdentifier(p.name) ? p.name.text : 'Anonymous Property';
-      const modifiers = ts.canHaveModifiers(p) ? ts.getModifiers(p) : undefined;
-      const matches = modifiers && modifiers.some((m: ts.Modifier) => m.kind === ts.SyntaxKind.ReadonlyKeyword);
-
-      if (isNot && matches) {
-        violations.push(`Property ${name} is readonly, but it shouldn't be.`);
-      } else if (!isNot && !matches) {
-        violations.push(`Property ${name} is not readonly, but it should be.`);
-      }
-    }
-    return {
-      pass: violations.length === 0,
-      message: () => violations.join('\n'),
-    };
-  }
-}

package/src/core/SliceLocator.ts

@@ -1,92 +0,0 @@
-import * as ts from 'typescript';
-import { RuleResult } from './types';
-
-export class SliceLocator {
-  private slicePattern: RegExp;
-  private sliceIds: Set<string> = new Set();
-  private sliceFiles: Map<string, ts.SourceFile[]> = new Map();
-
-  constructor(sourceFiles: ts.SourceFile[], private program: ts.Program, pattern: string) {
-    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-    const regexStr = escaped.replace(/\*/g, '([^/\\\\]+)');
-    this.slicePattern = new RegExp(regexStr);
-
-    for (const sf of sourceFiles) {
-      const match = sf.fileName.match(this.slicePattern);
-      if (match && match[1]) {
-        const sliceId = match[1];
-        this.sliceIds.add(sliceId);
-        if (!this.sliceFiles.has(sliceId)) {
-          this.sliceFiles.set(sliceId, []);
-        }
-        this.sliceFiles.get(sliceId)!.push(sf);
-      }
-    }
-  }
-
-  checkBeFreeOfCycles(isNot: boolean): RuleResult {
-    const graph: Map<string, Set<string>> = new Map();
-    for (const slice of this.sliceIds) {
-      graph.set(slice, new Set());
-    }
-
-    for (const [sliceId, files] of this.sliceFiles.entries()) {
-      for (const sf of files) {
-        ts.forEachChild(sf, (node) => {
-          if (ts.isImportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
-            const importPath = node.moduleSpecifier.text;
-            const resolved = ts.resolveModuleName(importPath, sf.fileName, this.program.getCompilerOptions(), ts.sys);
-            if (resolved.resolvedModule && resolved.resolvedModule.resolvedFileName) {
-              const targetMatch = resolved.resolvedModule.resolvedFileName.match(this.slicePattern);
-              if (targetMatch && targetMatch[1]) {
-                const targetSlice = targetMatch[1];
-                if (targetSlice !== sliceId && this.sliceIds.has(targetSlice)) {
-                  graph.get(sliceId)!.add(targetSlice);
-                }
-              }
-            }
-          }
-        });
-      }
-    }
-
-    const visited = new Set<string>();
-    const recursionStack = new Set<string>();
-    const violations: string[] = [];
-
-    const dfs = (node: string, path: string[]): boolean => {
-      visited.add(node);
-      recursionStack.add(node);
-
-      for (const neighbor of (graph.get(node) || [])) {
-        if (!visited.has(neighbor)) {
-          if (dfs(neighbor, [...path, neighbor])) return true;
-        } else if (recursionStack.has(neighbor)) {
-          violations.push(`Cycle detected between slices: ${path.join(' -> ')} -> ${neighbor}`);
-          return true;
-        }
-      }
-
-      recursionStack.delete(node);
-      return false;
-    };
-
-    for (const slice of this.sliceIds) {
-      if (!visited.has(slice)) {
-        dfs(slice, [slice]);
-      }
-    }
-
-    if (isNot) {
-      return {
-        pass: violations.length > 0,
-        message: () => violations.length > 0 ? '' : 'Expected cycles between slices but found none.'
-      };
-    } else {
-      return {
-        pass: violations.length === 0,
-        message: () => violations.join('\n')
-      };
-    }
-  }
-}