@archest/vitest 1.0.1 → 1.0.2

package/src/core/files/fileCheckHaveMaxExportedFunctions.ts

@@ -1,45 +0,0 @@
-import * as ts from 'typescript';
-import type { RuleResult } from '../types';
-import type { FileLocatorData } from './types';
-
-export function fileCheckHaveMaxExportedFunctions(
-  locator: FileLocatorData,
-  max: number,
-  isNot: boolean,
-): RuleResult {
-  const violations: string[] = [];
-  for (const file of locator.files) {
-    let exportedFuncCount = 0;
-
-    ts.forEachChild(file, (node) => {
-      if (ts.isFunctionDeclaration(node)) {
-        const modifiers = ts.canHaveModifiers(node)
-          ? ts.getModifiers(node)
-          : undefined;
-        if (modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
-          exportedFuncCount++;
-        }
-      }
-    });
-
-    const exceeds = exportedFuncCount > max;
-
-    if (isNot && exceeds) {
-      violations.push(
-        `File ${file.fileName} has ${exportedFuncCount} exported functions, which exceeds the maximum of ${max}, but it shouldn't.`,
-      );
-    } else if (!isNot && exceeds) {
-      violations.push(
-        `File ${file.fileName} has ${exportedFuncCount} exported functions, which exceeds the maximum of ${max}.`,
-      );
-    }
-  }
-  return {
-    pass: isNot ? violations.length > 0 : violations.length === 0,
-    message: () =>
-      violations.join('\n') ||
-      (isNot
-        ? 'Expected some files to exceed maximum exported functions, but none did.'
-        : ''),
-  };
-}

package/src/core/files/fileCheckHaveMinMaintainabilityIndex.test.ts

@@ -1,8 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { fileCheckHaveMinMaintainabilityIndex } from './fileCheckHaveMinMaintainabilityIndex';
-
-describe('fileCheckHaveMinMaintainabilityIndex', () => {
-  it('should exist and be callable', () => {
-    expect(typeof fileCheckHaveMinMaintainabilityIndex).toBe('function');
-  });
-});

package/src/core/files/fileCheckHaveMinMaintainabilityIndex.ts

@@ -1,19 +0,0 @@
-import { calculateMaintainabilityIndex } from '../metrics/calculateMaintainabilityIndex';
-import { sharedCheckHaveMinMaintainabilityIndex } from '../shared/sharedCheckHaveMinMaintainabilityIndex';
-import type { RuleResult } from '../types';
-import type { FileLocatorData } from './types';
-
-export function fileCheckHaveMinMaintainabilityIndex(
-  locator: FileLocatorData,
-  min: number,
-  isNot: boolean,
-): RuleResult {
-  return sharedCheckHaveMinMaintainabilityIndex(
-    locator.files,
-    (f) => f.fileName,
-    calculateMaintainabilityIndex,
-    'File',
-    min,
-    isNot,
-  );
-}

package/src/core/files/fileCheckMatchNamePattern.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile } from '../testUtils';
-import { fileCheckMatchNamePattern } from './fileCheckMatchNamePattern';
-import type { FileLocatorData } from './types';
-
-describe('fileCheckMatchNamePattern', () => {
-  it('should pass if filename matches', () => {
-    const sourceFile = createSourceFile(`// code`, 'src/core/test.ts');
-    const data: FileLocatorData = {
-      type: 'FileLocator',
-      files: [sourceFile],
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = fileCheckMatchNamePattern(data, /.*\.ts$/, false);
-    expect(result.pass).toBe(true);
-  });
-
-  it('should fail if filename does not match', () => {
-    const sourceFile = createSourceFile(`// code`, 'src/core/test.js');
-    const data: FileLocatorData = {
-      type: 'FileLocator',
-      files: [sourceFile],
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = fileCheckMatchNamePattern(data, /.*\.ts$/, false);
-    expect(result.pass).toBe(false);
-  });
-});

package/src/core/files/fileCheckMatchNamePattern.ts

@@ -1,17 +0,0 @@
-import { sharedCheckMatchNamePattern } from '../shared/sharedCheckMatchNamePattern';
-import type { RuleResult } from '../types';
-import type { FileLocatorData } from './types';
-
-export function fileCheckMatchNamePattern(
-  locator: FileLocatorData,
-  pattern: string | RegExp,
-  isNot: boolean,
-): RuleResult {
-  return sharedCheckMatchNamePattern(
-    locator.files,
-    (f) => f.fileName,
-    'File',
-    pattern,
-    isNot,
-  );
-}

package/src/core/files/getFileDependencies.ts

@@ -1,43 +0,0 @@
-import * as ts from 'typescript';
-
-export function getFileDependencies(
-  sourceFile: ts.SourceFile,
-  program: ts.Program,
-): string[] {
-  const dependencies: string[] = [];
-  const compilerOptions = program.getCompilerOptions();
-
-  const visit = (node: ts.Node) => {
-    if (ts.isImportDeclaration(node)) {
-      const moduleSpecifier = (node.moduleSpecifier as ts.StringLiteral).text;
-      const resolved = ts.resolveModuleName(
-        moduleSpecifier,
-        sourceFile.fileName,
-        compilerOptions,
-        ts.sys,
-      );
-      if (resolved.resolvedModule?.resolvedFileName) {
-        if (!resolved.resolvedModule.isExternalLibraryImport) {
-          dependencies.push(resolved.resolvedModule.resolvedFileName);
-        }
-      }
-    } else if (ts.isExportDeclaration(node) && node.moduleSpecifier) {
-      const moduleSpecifier = (node.moduleSpecifier as ts.StringLiteral).text;
-      const resolved = ts.resolveModuleName(
-        moduleSpecifier,
-        sourceFile.fileName,
-        compilerOptions,
-        ts.sys,
-      );
-      if (resolved.resolvedModule?.resolvedFileName) {
-        if (!resolved.resolvedModule.isExternalLibraryImport) {
-          dependencies.push(resolved.resolvedModule.resolvedFileName);
-        }
-      }
-    }
-    ts.forEachChild(node, visit);
-  };
-
-  visit(sourceFile);
-  return dependencies;
-}

package/src/core/files/locateFiles.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile } from '../testUtils';
-import { locateFiles } from './locateFiles';
-
-describe('locateFiles', () => {
-  it('should filter files by inFolder query', () => {
-    const file1 = createSourceFile('function a() {}', 'src/domain/file1.ts');
-    const file2 = createSourceFile('function b() {}', 'src/infra/file2.ts');
-    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-    const result = locateFiles([file1, file2], {} as any, {
-      inFolder: 'domain',
-    });
-    expect(result.files.length).toBe(1);
-    expect(result.files[0].fileName).toBe('src/domain/file1.ts');
-  });
-
-  it('should filter files by matchNamePattern query', () => {
-    const file1 = createSourceFile('function a() {}', 'src/domain/file1.ts');
-    const file2 = createSourceFile(
-      'function b() {}',
-      'src/domain/file2.spec.ts',
-    );
-    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-    const result = locateFiles([file1, file2], {} as any, {
-      matchNamePattern: /\.spec\.ts$/,
-    });
-    expect(result.files.length).toBe(1);
-    expect(result.files[0].fileName).toBe('src/domain/file2.spec.ts');
-  });
-});

package/src/core/files/locateFiles.ts

@@ -1,31 +0,0 @@
-import type * as ts from 'typescript';
-import type { FileLocatorData, FileQueryOptions } from './types';
-
-export function locateFiles(
-  sourceFiles: ts.SourceFile[],
-  program: ts.Program,
-  options?: FileQueryOptions,
-): FileLocatorData {
-  let filtered = sourceFiles;
-
-  if (options?.inFolder) {
-    filtered = filtered.filter(
-      (file) =>
-        file.fileName.includes(`/${options.inFolder}/`) ||
-        file.fileName.includes(`\\${options.inFolder}\\`),
-    );
-  }
-  if (options?.matchNamePattern) {
-    const regex =
-      typeof options.matchNamePattern === 'string'
-        ? new RegExp(options.matchNamePattern)
-        : options.matchNamePattern;
-    filtered = filtered.filter((file) => regex.test(file.fileName));
-  }
-
-  return {
-    type: 'FileLocator',
-    files: filtered,
-    program,
-  };
-}

package/src/core/files/types.ts

@@ -1,12 +0,0 @@
-import type * as ts from 'typescript';
-
-export interface FileLocatorData {
-  type: 'FileLocator';
-  files: ts.SourceFile[];
-  program: ts.Program;
-}
-
-export interface FileQueryOptions {
-  inFolder?: string;
-  matchNamePattern?: string | RegExp;
-}

package/src/core/functions/functionCheckHaveExplicitReturnType.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile, getFunctions } from '../testUtils';
-import { functionCheckHaveExplicitReturnType } from './functionCheckHaveExplicitReturnType';
-import type { FunctionLocatorData } from './types';
-
-describe('functionCheckHaveExplicitReturnType', () => {
-  it('should pass if function has explicit return type', () => {
-    const sourceFile = createSourceFile(`function myFunc(): void {}`);
-    const data: FunctionLocatorData = {
-      type: 'FunctionLocator',
-      functions: getFunctions(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = functionCheckHaveExplicitReturnType(data, false);
-    expect(result.pass).toBe(true);
-  });
-
-  it('should fail if function lacks explicit return type', () => {
-    const sourceFile = createSourceFile(`function myFunc() {}`);
-    const data: FunctionLocatorData = {
-      type: 'FunctionLocator',
-      functions: getFunctions(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = functionCheckHaveExplicitReturnType(data, false);
-    expect(result.pass).toBe(false);
-  });
-});

package/src/core/functions/functionCheckHaveExplicitReturnType.ts

@@ -1,29 +0,0 @@
-import * as ts from 'typescript';
-import type { RuleResult } from '../types';
-import type { FunctionLocatorData } from './types';
-
-export function functionCheckHaveExplicitReturnType(
-  locator: FunctionLocatorData,
-  isNot: boolean,
-): RuleResult {
-  const violations: string[] = [];
-  for (const f of locator.functions) {
-    const name =
-      f.name && ts.isIdentifier(f.name) ? f.name.text : 'Anonymous Function';
-    const hasType = !!f.type;
-
-    if (isNot && hasType) {
-      violations.push(
-        `Function ${name} has an explicit return type, but it shouldn't.`,
-      );
-    } else if (!isNot && !hasType) {
-      violations.push(
-        `Function ${name} does not have an explicit return type, but it should.`,
-      );
-    }
-  }
-  return {
-    pass: violations.length === 0,
-    message: () => violations.join('\n'),
-  };
-}

package/src/core/functions/functionCheckHaveMaxCyclomaticComplexity.test.ts

@@ -1,8 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { functionCheckHaveMaxCyclomaticComplexity } from './functionCheckHaveMaxCyclomaticComplexity';
-
-describe('functionCheckHaveMaxCyclomaticComplexity', () => {
-  it('should exist and be callable', () => {
-    expect(typeof functionCheckHaveMaxCyclomaticComplexity).toBe('function');
-  });
-});

package/src/core/functions/functionCheckHaveMaxCyclomaticComplexity.ts

@@ -1,20 +0,0 @@
-import * as ts from 'typescript';
-import { calculateCyclomaticComplexity } from '../metrics/calculateCyclomaticComplexity';
-import { sharedCheckHaveMaxCyclomaticComplexity } from '../shared/sharedCheckHaveMaxCyclomaticComplexity';
-import type { RuleResult } from '../types';
-import type { FunctionLocatorData } from './types';
-
-export function functionCheckHaveMaxCyclomaticComplexity(
-  locator: FunctionLocatorData,
-  max: number,
-  isNot: boolean,
-): RuleResult {
-  return sharedCheckHaveMaxCyclomaticComplexity(
-    locator.functions,
-    (f) => (f.name && ts.isIdentifier(f.name) ? f.name.text : undefined),
-    calculateCyclomaticComplexity,
-    'Function',
-    max,
-    isNot,
-  );
-}

package/src/core/functions/functionCheckHaveMinMaintainabilityIndex.test.ts

@@ -1,8 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { functionCheckHaveMinMaintainabilityIndex } from './functionCheckHaveMinMaintainabilityIndex';
-
-describe('functionCheckHaveMinMaintainabilityIndex', () => {
-  it('should exist and be callable', () => {
-    expect(typeof functionCheckHaveMinMaintainabilityIndex).toBe('function');
-  });
-});

package/src/core/functions/functionCheckHaveMinMaintainabilityIndex.ts

@@ -1,20 +0,0 @@
-import * as ts from 'typescript';
-import { calculateMaintainabilityIndex } from '../metrics/calculateMaintainabilityIndex';
-import { sharedCheckHaveMinMaintainabilityIndex } from '../shared/sharedCheckHaveMinMaintainabilityIndex';
-import type { RuleResult } from '../types';
-import type { FunctionLocatorData } from './types';
-
-export function functionCheckHaveMinMaintainabilityIndex(
-  locator: FunctionLocatorData,
-  min: number,
-  isNot: boolean,
-): RuleResult {
-  return sharedCheckHaveMinMaintainabilityIndex(
-    locator.functions,
-    (f) => (f.name && ts.isIdentifier(f.name) ? f.name.text : undefined),
-    calculateMaintainabilityIndex,
-    'Function',
-    min,
-    isNot,
-  );
-}

package/src/core/functions/functionCheckHaveModifier.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile, getFunctions } from '../testUtils';
-import { functionCheckHaveModifier } from './functionCheckHaveModifier';
-import type { FunctionLocatorData } from './types';
-
-describe('functionCheckHaveModifier', () => {
-  it('should pass if function has modifier', () => {
-    const sourceFile = createSourceFile(`export function myFunc() {}`);
-    const data: FunctionLocatorData = {
-      type: 'FunctionLocator',
-      functions: getFunctions(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = functionCheckHaveModifier(data, 'export', false);
-    expect(result.pass).toBe(true);
-  });
-
-  it('should fail if function lacks modifier', () => {
-    const sourceFile = createSourceFile(`function myFunc() {}`);
-    const data: FunctionLocatorData = {
-      type: 'FunctionLocator',
-      functions: getFunctions(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = functionCheckHaveModifier(data, 'export', false);
-    expect(result.pass).toBe(false);
-  });
-});

package/src/core/functions/functionCheckHaveModifier.ts

@@ -1,18 +0,0 @@
-import * as ts from 'typescript';
-import { sharedCheckHaveModifier } from '../shared/sharedCheckHaveModifier';
-import type { RuleResult } from '../types';
-import type { FunctionLocatorData } from './types';
-
-export function functionCheckHaveModifier(
-  locator: FunctionLocatorData,
-  modifierStr: string,
-  isNot: boolean,
-): RuleResult {
-  return sharedCheckHaveModifier(
-    locator.functions,
-    (f) => (f.name && ts.isIdentifier(f.name) ? f.name.text : undefined),
-    'Function',
-    modifierStr,
-    isNot,
-  );
-}

package/src/core/functions/functionCheckHaveNameMatchingFileName.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile, getFunctions } from '../testUtils';
-import { functionCheckHaveNameMatchingFileName } from './functionCheckHaveNameMatchingFileName';
-import type { FunctionLocatorData } from './types';
-
-describe('functionCheckHaveNameMatchingFileName', () => {
-  it('should pass if function matches filename', () => {
-    const sourceFile = createSourceFile(`function test() {}`, 'test.ts');
-    const data: FunctionLocatorData = {
-      type: 'FunctionLocator',
-      functions: getFunctions(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = functionCheckHaveNameMatchingFileName(data, false);
-    expect(result.pass).toBe(true);
-  });
-
-  it('should fail if function does not match filename', () => {
-    const sourceFile = createSourceFile(`function test() {}`, 'other.ts');
-    const data: FunctionLocatorData = {
-      type: 'FunctionLocator',
-      functions: getFunctions(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = functionCheckHaveNameMatchingFileName(data, false);
-    expect(result.pass).toBe(false);
-  });
-});

package/src/core/functions/functionCheckHaveNameMatchingFileName.ts

@@ -1,16 +0,0 @@
-import * as ts from 'typescript';
-import { sharedCheckHaveNameMatchingFileName } from '../shared/sharedCheckHaveNameMatchingFileName';
-import type { RuleResult } from '../types';
-import type { FunctionLocatorData } from './types';
-
-export function functionCheckHaveNameMatchingFileName(
-  locator: FunctionLocatorData,
-  isNot: boolean,
-): RuleResult {
-  return sharedCheckHaveNameMatchingFileName(
-    locator.functions,
-    (f) => (f.name && ts.isIdentifier(f.name) ? f.name.text : undefined),
-    'Function',
-    isNot,
-  );
-}

package/src/core/functions/functionCheckMatchNamePattern.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile, getFunctions } from '../testUtils';
-import { functionCheckMatchNamePattern } from './functionCheckMatchNamePattern';
-import type { FunctionLocatorData } from './types';
-
-describe('functionCheckMatchNamePattern', () => {
-  it('should pass if function matches pattern', () => {
-    const sourceFile = createSourceFile(`function testFunc() {}`);
-    const data: FunctionLocatorData = {
-      type: 'FunctionLocator',
-      functions: getFunctions(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = functionCheckMatchNamePattern(data, /^test/, false);
-    expect(result.pass).toBe(true);
-  });
-
-  it('should fail if function does not match pattern', () => {
-    const sourceFile = createSourceFile(`function myFunc() {}`);
-    const data: FunctionLocatorData = {
-      type: 'FunctionLocator',
-      functions: getFunctions(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = functionCheckMatchNamePattern(data, /^test/, false);
-    expect(result.pass).toBe(false);
-  });
-});

package/src/core/functions/functionCheckMatchNamePattern.ts

@@ -1,18 +0,0 @@
-import * as ts from 'typescript';
-import { sharedCheckMatchNamePattern } from '../shared/sharedCheckMatchNamePattern';
-import type { RuleResult } from '../types';
-import type { FunctionLocatorData } from './types';
-
-export function functionCheckMatchNamePattern(
-  locator: FunctionLocatorData,
-  pattern: string | RegExp,
-  isNot: boolean,
-): RuleResult {
-  return sharedCheckMatchNamePattern(
-    locator.functions,
-    (f) => (f.name && ts.isIdentifier(f.name) ? f.name.text : undefined),
-    'Function',
-    pattern,
-    isNot,
-  );
-}

package/src/core/functions/locateFunctions.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile, getFunctions } from '../testUtils';
-import { locateFunctions } from './locateFunctions';
-
-describe('locateFunctions', () => {
-  it('should filter functions by matchNamePattern', () => {
-    const file1 = createSourceFile('function a() {}; function b() {}');
-    const functions = getFunctions(file1);
-    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-    const result = locateFunctions(functions, {} as any, {
-      matchNamePattern: 'a',
-    });
-    expect(result.functions.length).toBe(1);
-    expect(result.functions[0].name?.text).toBe('a');
-  });
-});

package/src/core/functions/locateFunctions.ts

@@ -1,47 +0,0 @@
-import * as ts from 'typescript';
-import type { FunctionLocatorData, FunctionQueryOptions } from './types';
-
-export function locateFunctions(
-  functions: ts.FunctionLikeDeclaration[],
-  program: ts.Program,
-  options?: FunctionQueryOptions,
-): FunctionLocatorData {
-  let filtered = functions;
-
-  if (options?.inFolder) {
-    filtered = filtered.filter((f) => {
-      const sourceFile = f.getSourceFile
-        ? f.getSourceFile()
-        : f.parent
-          ? ts.getSourceFileOfNode(f)
-          : undefined;
-      if (!sourceFile) return false;
-      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((f) => {
-      return f.name && ts.isIdentifier(f.name) && regex.test(f.name.text);
-    });
-  }
-
-  if (options?.isTopLevel) {
-    filtered = filtered.filter((f) => {
-      return ts.isSourceFile(f.parent);
-    });
-  }
-
-  return {
-    type: 'FunctionLocator',
-    functions: filtered,
-    program,
-  };
-}

package/src/core/functions/types.ts

@@ -1,13 +0,0 @@
-import type * as ts from 'typescript';
-
-export interface FunctionLocatorData {
-  type: 'FunctionLocator';
-  functions: ts.FunctionLikeDeclaration[];
-  program: ts.Program;
-}
-
-export interface FunctionQueryOptions {
-  inFolder?: string;
-  matchNamePattern?: string | RegExp;
-  isTopLevel?: boolean;
-}

package/src/core/layers/checkLayeredArchitecture.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { checkLayeredArchitecture } from './checkLayeredArchitecture';
-import { createLayeredArchitecture } from './createLayeredArchitecture';
-
-describe('checkLayeredArchitecture', () => {
-  it('should evaluate all assertions and return true if none fail', () => {
-    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-    const data = createLayeredArchitecture([], {} as any);
-    data.assertions.push(() => []); // returns no violations
-    const result = checkLayeredArchitecture(data);
-    expect(result.pass).toBe(true);
-    expect(result.message()).toBe('');
-  });
-
-  it('should return false if any assertion yields violations', () => {
-    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-    const data = createLayeredArchitecture([], {} as any);
-    data.assertions.push(() => ['Layer violation!']);
-    const result = checkLayeredArchitecture(data);
-    expect(result.pass).toBe(false);
-    expect(result.message()).toBe('Layer violation!');
-  });
-});

package/src/core/layers/checkLayeredArchitecture.ts

@@ -1,15 +0,0 @@
-import type { RuleResult } from '../types';
-import type { LayeredArchitectureData } from './types';
-
-export function checkLayeredArchitecture(
-  data: LayeredArchitectureData,
-): RuleResult {
-  const violations: string[] = [];
-  for (const assertion of data.assertions) {
-    violations.push(...assertion(data.files));
-  }
-  return {
-    pass: violations.length === 0,
-    message: () => violations.join('\n'),
-  };
-}

package/src/core/layers/createLayeredArchitecture.test.ts

@@ -1,13 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createLayeredArchitecture } from './createLayeredArchitecture';
-
-describe('createLayeredArchitecture', () => {
-  it('should initialize a LayeredArchitectureData object', () => {
-    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-    const data = createLayeredArchitecture([], {} as any);
-    expect(data.type).toBe('LayeredArchitecture');
-    expect(data.files).toEqual([]);
-    expect(data.layers.size).toBe(0);
-    expect(data.assertions.length).toBe(0);
-  });
-});