@archest/vitest 1.0.0 → 1.0.1

package/dist/src/core/properties/locateProperties.d.ts

@@ -0,0 +1,3 @@
+import { PropertyLocatorData, PropertyQueryOptions } from './types';
+import * as ts from 'typescript';
+export declare function locateProperties(properties: ts.PropertyDeclaration[], program: ts.Program, options?: PropertyQueryOptions): PropertyLocatorData;

package/dist/src/core/properties/propertyCheckBeReadonly.d.ts

@@ -0,0 +1,3 @@
+import { RuleResult } from '../types';
+import { PropertyLocatorData } from './types';
+export declare function propertyCheckBeReadonly(locator: PropertyLocatorData, isNot: boolean): RuleResult;

package/dist/src/core/properties/types.d.ts

@@ -0,0 +1,10 @@
+import type * as ts from 'typescript';
+export interface PropertyLocatorData {
+    type: 'PropertyLocator';
+    properties: ts.PropertyDeclaration[];
+    program: ts.Program;
+}
+export interface PropertyQueryOptions {
+    inFolder?: string;
+    matchNamePattern?: string | RegExp;
+}

package/dist/src/core/shared/sharedCheckHaveMaxCyclomaticComplexity.d.ts

@@ -0,0 +1 @@
+export declare function sharedCheckHaveMaxCyclomaticComplexity<T>(items: T[], getName: (item: T) => string | undefined, getComplexity: (item: T) => number, label: string, max: number, isNot: boolean): import('../types').RuleResult;

package/dist/src/core/shared/sharedCheckHaveMinMaintainabilityIndex.d.ts

@@ -0,0 +1 @@
+export declare function sharedCheckHaveMinMaintainabilityIndex<T>(items: T[], getName: (item: T) => string | undefined, getMi: (item: T) => number, label: string, min: number, isNot: boolean): import('../types').RuleResult;

package/dist/src/core/shared/sharedCheckHaveModifier.d.ts

@@ -0,0 +1,2 @@
+import * as ts from 'typescript';
+export declare function sharedCheckHaveModifier<T extends ts.Node>(items: T[], getName: (item: T) => string | undefined, label: string, modifierStr: string, isNot: boolean): import('../types').RuleResult;

package/dist/src/core/shared/sharedCheckHaveNameMatchingFileName.d.ts

@@ -0,0 +1,2 @@
+import * as ts from 'typescript';
+export declare function sharedCheckHaveNameMatchingFileName<T extends ts.Node>(items: T[], getName: (item: T) => string | undefined, label: string, isNot: boolean): import('../types').RuleResult;

package/dist/src/core/shared/sharedCheckMatchNamePattern.d.ts

@@ -0,0 +1 @@
+export declare function sharedCheckMatchNamePattern<T>(items: T[], getName: (item: T) => string | undefined, label: string, pattern: string | RegExp, isNot: boolean): import('../types').RuleResult;

package/dist/src/core/slices/locateSlices.d.ts

@@ -0,0 +1,3 @@
+import { SliceLocatorData } from './types';
+import type * as ts from 'typescript';
+export declare function locateSlices(sourceFiles: ts.SourceFile[], program: ts.Program, pattern: string): SliceLocatorData;

package/dist/src/core/slices/sliceCheckBeFreeOfCycles.d.ts

@@ -0,0 +1,3 @@
+import { RuleResult } from '../types';
+import { SliceLocatorData } from './types';
+export declare function sliceCheckBeFreeOfCycles(locator: SliceLocatorData, isNot: boolean): RuleResult;

package/dist/src/core/slices/sliceCheckHaveMaxDistanceFromMainSequence.d.ts

@@ -0,0 +1,3 @@
+import { RuleResult } from '../types';
+import { SliceLocatorData } from './types';
+export declare function sliceCheckHaveMaxDistanceFromMainSequence(locator: SliceLocatorData, max: number, isNot: boolean): RuleResult;

package/dist/src/core/slices/types.d.ts

@@ -0,0 +1,8 @@
+import type * as ts from 'typescript';
+export interface SliceLocatorData {
+    type: 'SliceLocator';
+    slicePattern: RegExp;
+    sliceIds: Set<string>;
+    sliceFiles: Map<string, ts.SourceFile[]>;
+    program: ts.Program;
+}

package/dist/src/core/types.d.ts

@@ -1,4 +1,11 @@
+import { ClassLocatorData } from './classes/types';
+import { FileLocatorData } from './files/types';
+import { FunctionLocatorData } from './functions/types';
+import { LayeredArchitectureData } from './layers/types';
+import { PropertyLocatorData } from './properties/types';
+import { SliceLocatorData } from './slices/types';
 export interface RuleResult {
     pass: boolean;
     message: () => string;
 }
+export type LocatorData = FileLocatorData | ClassLocatorData | FunctionLocatorData | PropertyLocatorData | SliceLocatorData | LayeredArchitectureData;

package/dist/src/core/utils/ruleBuilder.d.ts

@@ -0,0 +1,6 @@
+import { RuleResult } from '../types';
+export declare function ruleBuilder<T>(items: T[], isNot: boolean, evaluate: (item: T) => {
+    passes: boolean;
+    failMessage: string;
+    failNotMessage: string;
+}): RuleResult;

package/dist/src/index.d.ts

@@ -1,9 +1,35 @@
-export { Project, parseProject } from './core/Project';
-export { setupMatchers } from './matchers';
-export * from './core/FileLocator';
-export * from './core/ClassLocator';
-export * from './core/FunctionLocator';
-export * from './core/PropertyLocator';
-export * from './core/SliceLocator';
-export * from './core/LayerLocator';
+export * from './core/classes/classCheckExtendClass';
+export * from './core/classes/classCheckHaveMaxCyclomaticComplexity';
+export * from './core/classes/classCheckHaveModifier';
+export * from './core/classes/classCheckHaveNameMatchingFileName';
+export * from './core/classes/classCheckImplementInterface';
+export * from './core/classes/classCheckMatchNamePattern';
+export * from './core/classes/classCheckResideInFolder';
+export * from './core/classes/locateClasses';
+export * from './core/files/checkDependOnFilesInFolder';
+export * from './core/files/fileCheckBeFreeOfCycles';
+export * from './core/files/fileCheckHaveMaxCyclomaticComplexity';
+export * from './core/files/fileCheckHaveMaxExportedFunctions';
+export * from './core/files/fileCheckHaveMinMaintainabilityIndex';
+export * from './core/files/fileCheckMatchNamePattern';
+export * from './core/files/locateFiles';
+export * from './core/functions/functionCheckHaveExplicitReturnType';
+export * from './core/functions/functionCheckHaveMaxCyclomaticComplexity';
+export * from './core/functions/functionCheckHaveMinMaintainabilityIndex';
+export * from './core/functions/functionCheckHaveModifier';
+export * from './core/functions/functionCheckHaveNameMatchingFileName';
+export * from './core/functions/functionCheckMatchNamePattern';
+export * from './core/functions/locateFunctions';
+export * from './core/layers/checkLayeredArchitecture';
+export * from './core/layers/createLayeredArchitecture';
+export * from './core/layers/layer';
+export * from './core/layers/layerShouldNotBeAccessedByAnyLayer';
+export * from './core/layers/layerShouldOnlyBeAccessedBy';
+export { parseProject } from './core/project/parseProject';
+export * from './core/properties/locateProperties';
+export * from './core/properties/propertyCheckBeReadonly';
+export * from './core/slices/locateSlices';
+export * from './core/slices/sliceCheckBeFreeOfCycles';
+export * from './core/slices/sliceCheckHaveMaxDistanceFromMainSequence';
 export * from './core/types';
+export { setupMatchers } from './matchers';

package/dist/src/matchers/index.d.ts

@@ -11,5 +11,10 @@ declare module 'vitest' {
         toDependOnFilesInFolder(folder: string): void;
         toBeFreeOfCycles(): void;
         toMatchNamePattern(pattern: string | RegExp): void;
+        toHaveMaxCyclomaticComplexity(max: number): void;
+        toHaveMinMaintainabilityIndex(min: number): void;
+        toHaveMaxDistanceFromMainSequence(max: number): void;
+        toHaveNameMatchingFileName(): void;
+        toHaveMaxExportedFunctions(max: number): void;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archest/vitest",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/hinterdupfinger/archest.git"

package/src/core/classes/classCheckExtendClass.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile, getClasses } from '../testUtils';
+import { classCheckExtendClass } from './classCheckExtendClass';
+import type { ClassLocatorData } from './types';
+
+describe('classCheckExtendClass', () => {
+  it('should pass if class extends correctly', () => {
+    const sourceFile = createSourceFile(`class Test extends Base {}`);
+    const data: ClassLocatorData = {
+      type: 'ClassLocator',
+      classes: getClasses(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = classCheckExtendClass(data, 'Base', false);
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if class does not extend correctly', () => {
+    const sourceFile = createSourceFile(`class Test extends Other {}`);
+    const data: ClassLocatorData = {
+      type: 'ClassLocator',
+      classes: getClasses(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = classCheckExtendClass(data, 'Base', false);
+    expect(result.pass).toBe(false);
+  });
+});

package/src/core/classes/classCheckExtendClass.ts

@@ -0,0 +1,41 @@
+import * as ts from 'typescript';
+import type { RuleResult } from '../types';
+import type { ClassLocatorData } from './types';
+
+export function classCheckExtendClass(
+  locator: ClassLocatorData,
+  className: string,
+  isNot: boolean,
+): RuleResult {
+  const violations: string[] = [];
+  for (const c of locator.classes) {
+    const name = c.name?.text || 'Anonymous';
+    let matches = false;
+    if (c.heritageClauses) {
+      for (const clause of c.heritageClauses) {
+        if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
+          for (const type of clause.types) {
+            if (
+              ts.isIdentifier(type.expression) &&
+              type.expression.text === className
+            ) {
+              matches = true;
+              break;
+            }
+          }
+        }
+      }
+    }
+    if (isNot && matches) {
+      violations.push(`Class ${name} extends ${className}, but it shouldn't.`);
+    } else if (!isNot && !matches) {
+      violations.push(
+        `Class ${name} does not extend ${className}, but it should.`,
+      );
+    }
+  }
+  return {
+    pass: violations.length === 0,
+    message: () => violations.join('\n'),
+  };
+}

package/src/core/classes/classCheckHaveMaxCyclomaticComplexity.test.ts

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

package/src/core/classes/classCheckHaveMaxCyclomaticComplexity.ts

@@ -0,0 +1,35 @@
+import * as ts from 'typescript';
+import { calculateCyclomaticComplexity } from '../metrics/calculateCyclomaticComplexity';
+import { sharedCheckHaveMaxCyclomaticComplexity } from '../shared/sharedCheckHaveMaxCyclomaticComplexity';
+import type { RuleResult } from '../types';
+import type { ClassLocatorData } from './types';
+
+export function classCheckHaveMaxCyclomaticComplexity(
+  locator: ClassLocatorData,
+  max: number,
+  isNot: boolean,
+): RuleResult {
+  return sharedCheckHaveMaxCyclomaticComplexity(
+    locator.classes,
+    (c) => c.name?.text,
+    (c) => {
+      let complexity = 0;
+      const visit = (node: ts.Node) => {
+        if (
+          ts.isMethodDeclaration(node) ||
+          ts.isConstructorDeclaration(node) ||
+          ts.isGetAccessor(node) ||
+          ts.isSetAccessor(node)
+        ) {
+          complexity += calculateCyclomaticComplexity(node);
+        }
+        ts.forEachChild(node, visit);
+      };
+      visit(c);
+      return complexity;
+    },
+    'Class',
+    max,
+    isNot,
+  );
+}

package/src/core/classes/classCheckHaveModifier.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile, getClasses } from '../testUtils';
+import { classCheckHaveModifier } from './classCheckHaveModifier';
+import type { ClassLocatorData } from './types';
+
+describe('classCheckHaveModifier', () => {
+  it('should pass if class has modifier', () => {
+    const sourceFile = createSourceFile(`export class Test {}`);
+    const data: ClassLocatorData = {
+      type: 'ClassLocator',
+      classes: getClasses(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = classCheckHaveModifier(data, 'export', false);
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if class does not have modifier', () => {
+    const sourceFile = createSourceFile(`class Test {}`);
+    const data: ClassLocatorData = {
+      type: 'ClassLocator',
+      classes: getClasses(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = classCheckHaveModifier(data, 'export', false);
+    expect(result.pass).toBe(false);
+  });
+});

package/src/core/classes/classCheckHaveModifier.ts

@@ -0,0 +1,17 @@
+import { sharedCheckHaveModifier } from '../shared/sharedCheckHaveModifier';
+import type { RuleResult } from '../types';
+import type { ClassLocatorData } from './types';
+
+export function classCheckHaveModifier(
+  locator: ClassLocatorData,
+  modifierStr: string,
+  isNot: boolean,
+): RuleResult {
+  return sharedCheckHaveModifier(
+    locator.classes,
+    (c) => c.name?.text,
+    'Class',
+    modifierStr,
+    isNot,
+  );
+}

package/src/core/classes/classCheckHaveNameMatchingFileName.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile, getClasses } from '../testUtils';
+import { classCheckHaveNameMatchingFileName } from './classCheckHaveNameMatchingFileName';
+import type { ClassLocatorData } from './types';
+
+describe('classCheckHaveNameMatchingFileName', () => {
+  it('should pass if class matches filename', () => {
+    const sourceFile = createSourceFile(`class Test {}`, 'Test.ts');
+    const data: ClassLocatorData = {
+      type: 'ClassLocator',
+      classes: getClasses(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = classCheckHaveNameMatchingFileName(data, false);
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if class does not match filename', () => {
+    const sourceFile = createSourceFile(`class Test {}`, 'Other.ts');
+    const data: ClassLocatorData = {
+      type: 'ClassLocator',
+      classes: getClasses(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = classCheckHaveNameMatchingFileName(data, false);
+    expect(result.pass).toBe(false);
+  });
+});

package/src/core/classes/classCheckHaveNameMatchingFileName.ts

@@ -0,0 +1,15 @@
+import { sharedCheckHaveNameMatchingFileName } from '../shared/sharedCheckHaveNameMatchingFileName';
+import type { RuleResult } from '../types';
+import type { ClassLocatorData } from './types';
+
+export function classCheckHaveNameMatchingFileName(
+  locator: ClassLocatorData,
+  isNot: boolean,
+): RuleResult {
+  return sharedCheckHaveNameMatchingFileName(
+    locator.classes,
+    (c) => c.name?.text,
+    'Class',
+    isNot,
+  );
+}

package/src/core/classes/classCheckImplementInterface.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile, getClasses } from '../testUtils';
+import { classCheckImplementInterface } from './classCheckImplementInterface';
+import type { ClassLocatorData } from './types';
+
+describe('classCheckImplementInterface', () => {
+  it('should pass if class implements interface', () => {
+    const sourceFile = createSourceFile(`class Test implements IBase {}`);
+    const data: ClassLocatorData = {
+      type: 'ClassLocator',
+      classes: getClasses(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = classCheckImplementInterface(data, 'IBase', false);
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if class does not implement interface', () => {
+    const sourceFile = createSourceFile(`class Test {}`);
+    const data: ClassLocatorData = {
+      type: 'ClassLocator',
+      classes: getClasses(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = classCheckImplementInterface(data, 'IBase', false);
+    expect(result.pass).toBe(false);
+  });
+});

package/src/core/classes/classCheckImplementInterface.ts

@@ -0,0 +1,43 @@
+import * as ts from 'typescript';
+import type { RuleResult } from '../types';
+import type { ClassLocatorData } from './types';
+
+export function classCheckImplementInterface(
+  locator: ClassLocatorData,
+  interfaceName: string,
+  isNot: boolean,
+): RuleResult {
+  const violations: string[] = [];
+  for (const c of locator.classes) {
+    const name = c.name?.text || 'Anonymous';
+    let matches = false;
+    if (c.heritageClauses) {
+      for (const clause of c.heritageClauses) {
+        if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+          for (const type of clause.types) {
+            if (
+              ts.isIdentifier(type.expression) &&
+              type.expression.text === interfaceName
+            ) {
+              matches = true;
+              break;
+            }
+          }
+        }
+      }
+    }
+    if (isNot && matches) {
+      violations.push(
+        `Class ${name} implements ${interfaceName}, but it shouldn't.`,
+      );
+    } else if (!isNot && !matches) {
+      violations.push(
+        `Class ${name} does not implement ${interfaceName}, but it should.`,
+      );
+    }
+  }
+  return {
+    pass: violations.length === 0,
+    message: () => violations.join('\n'),
+  };
+}

package/src/core/classes/classCheckMatchNamePattern.test.ts

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

package/src/core/classes/classCheckMatchNamePattern.ts

@@ -0,0 +1,17 @@
+import { sharedCheckMatchNamePattern } from '../shared/sharedCheckMatchNamePattern';
+import type { RuleResult } from '../types';
+import type { ClassLocatorData } from './types';
+
+export function classCheckMatchNamePattern(
+  locator: ClassLocatorData,
+  pattern: string | RegExp,
+  isNot: boolean,
+): RuleResult {
+  return sharedCheckMatchNamePattern(
+    locator.classes,
+    (c) => c.name?.text,
+    'Class',
+    pattern,
+    isNot,
+  );
+}

package/src/core/classes/classCheckResideInFolder.test.ts

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

package/src/core/classes/classCheckResideInFolder.ts

@@ -0,0 +1,31 @@
+import type { RuleResult } from '../types';
+import type { ClassLocatorData } from './types';
+
+export function classCheckResideInFolder(
+  locator: ClassLocatorData,
+  targetFolder: string,
+  isNot: boolean,
+): RuleResult {
+  const violations: string[] = [];
+  for (const c of locator.classes) {
+    const className = c.name?.text || 'Anonymous Class';
+    const sourceFile = c.getSourceFile();
+    const inTargetFolder =
+      sourceFile.fileName.includes(`/${targetFolder}/`) ||
+      sourceFile.fileName.includes(`\\${targetFolder}\\`);
+
+    if (isNot && inTargetFolder) {
+      violations.push(
+        `Class ${className} resides in ${targetFolder}, but it shouldn't.`,
+      );
+    } else if (!isNot && !inTargetFolder) {
+      violations.push(
+        `Class ${className} does not reside in ${targetFolder}, but it should.`,
+      );
+    }
+  }
+  return {
+    pass: violations.length === 0,
+    message: () => violations.join('\n'),
+  };
+}

package/src/core/classes/locateClasses.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile, getClasses } from '../testUtils';
+import { locateClasses } from './locateClasses';
+
+describe('locateClasses', () => {
+  it('should filter classes by inFolder', () => {
+    const file1 = createSourceFile('class A {}', 'src/domain/A.ts');
+    const classes = getClasses(file1);
+    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+    const result = locateClasses(classes, {} as any, { inFolder: 'infra' });
+    expect(result.classes.length).toBe(0);
+  });
+});

package/src/core/classes/locateClasses.ts

@@ -0,0 +1,127 @@
+import * as ts from 'typescript';
+import type { ClassLocatorData, ClassQueryOptions } from './types';
+
+export function locateClasses(
+  classes: ts.ClassDeclaration[],
+  program: ts.Program,
+  options?: ClassQueryOptions,
+): ClassLocatorData {
+  let filtered = classes;
+
+  if (options?.inFolder) {
+    filtered = filtered.filter((c) => {
+      const sourceFile = c.getSourceFile
+        ? c.getSourceFile()
+        : c.parent
+          ? ts.getSourceFileOfNode(c)
+          : 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((c) => {
+      const name = c.name?.text;
+      return name && regex.test(name);
+    });
+  }
+  if (options?.withDecorator) {
+    filtered = filtered.filter((c) => {
+      const decorators = ts.canHaveDecorators(c)
+        ? ts.getDecorators(c)
+        : undefined;
+      let hasDecorator = false;
+      if (decorators) {
+        for (const dec of decorators) {
+          const exp = dec.expression;
+          let name = '';
+          if (ts.isIdentifier(exp)) {
+            name = exp.text;
+          } else if (
+            ts.isCallExpression(exp) &&
+            ts.isIdentifier(exp.expression)
+          ) {
+            name = exp.expression.text;
+          }
+          if (name === options.withDecorator) {
+            hasDecorator = true;
+          }
+        }
+      }
+      return hasDecorator;
+    });
+  }
+  if (options?.extending) {
+    filtered = filtered.filter((c) => {
+      if (c.heritageClauses) {
+        for (const clause of c.heritageClauses) {
+          if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
+            for (const type of clause.types) {
+              if (
+                ts.isIdentifier(type.expression) &&
+                type.expression.text === options.extending
+              ) {
+                return true;
+              }
+            }
+          }
+        }
+      }
+      return false;
+    });
+  }
+  if (options?.implementing) {
+    filtered = filtered.filter((c) => {
+      if (c.heritageClauses) {
+        for (const clause of c.heritageClauses) {
+          if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+            for (const type of clause.types) {
+              if (
+                ts.isIdentifier(type.expression) &&
+                type.expression.text === options.implementing
+              ) {
+                return true;
+              }
+            }
+          }
+        }
+      }
+      return false;
+    });
+  }
+  if (options?.havingModifier) {
+    let targetKind: ts.SyntaxKind;
+    switch (options.havingModifier) {
+      case 'export':
+        targetKind = ts.SyntaxKind.ExportKeyword;
+        break;
+      case 'default':
+        targetKind = ts.SyntaxKind.DefaultKeyword;
+        break;
+      case 'abstract':
+        targetKind = ts.SyntaxKind.AbstractKeyword;
+        break;
+      default:
+        throw new Error(
+          `Modifier ${options.havingModifier} is not fully supported.`,
+        );
+    }
+    filtered = filtered.filter((c) => {
+      const modifiers = ts.canHaveModifiers(c) ? ts.getModifiers(c) : undefined;
+      return modifiers?.some((m: ts.Modifier) => m.kind === targetKind);
+    });
+  }
+
+  return {
+    type: 'ClassLocator',
+    classes: filtered,
+    program,
+  };
+}