@archest/vitest 1.0.0 → 1.0.1

package/src/matchers/index.ts

@@ -1,107 +1,320 @@
 import { expect } from 'vitest';
-import { RuleResult } from '../core/types';
-import { ClassLocator } from '../core/ClassLocator';
-import { FunctionLocator } from '../core/FunctionLocator';
-import { PropertyLocator } from '../core/PropertyLocator';
-import { FileLocator } from '../core/FileLocator';
-import { SliceLocator } from '../core/SliceLocator';
-import { LayeredArchitectureBuilder } from '../core/LayerLocator';
+import { classCheckExtendClass } from '../core/classes/classCheckExtendClass';
+import { classCheckHaveMaxCyclomaticComplexity } from '../core/classes/classCheckHaveMaxCyclomaticComplexity';
+import { classCheckHaveModifier } from '../core/classes/classCheckHaveModifier';
+import { classCheckHaveNameMatchingFileName } from '../core/classes/classCheckHaveNameMatchingFileName';
+import { classCheckImplementInterface } from '../core/classes/classCheckImplementInterface';
+import { classCheckMatchNamePattern } from '../core/classes/classCheckMatchNamePattern';
+import { classCheckResideInFolder } from '../core/classes/classCheckResideInFolder';
+import { checkDependOnFilesInFolder } from '../core/files/checkDependOnFilesInFolder';
+import { fileCheckBeFreeOfCycles } from '../core/files/fileCheckBeFreeOfCycles';
+import { fileCheckHaveMaxCyclomaticComplexity } from '../core/files/fileCheckHaveMaxCyclomaticComplexity';
+import { fileCheckHaveMaxExportedFunctions } from '../core/files/fileCheckHaveMaxExportedFunctions';
+import { fileCheckHaveMinMaintainabilityIndex } from '../core/files/fileCheckHaveMinMaintainabilityIndex';
+import { fileCheckMatchNamePattern } from '../core/files/fileCheckMatchNamePattern';
+import { functionCheckHaveExplicitReturnType } from '../core/functions/functionCheckHaveExplicitReturnType';
+import { functionCheckHaveMaxCyclomaticComplexity } from '../core/functions/functionCheckHaveMaxCyclomaticComplexity';
+import { functionCheckHaveMinMaintainabilityIndex } from '../core/functions/functionCheckHaveMinMaintainabilityIndex';
+import { functionCheckHaveModifier } from '../core/functions/functionCheckHaveModifier';
+import { functionCheckHaveNameMatchingFileName } from '../core/functions/functionCheckHaveNameMatchingFileName';
+import { functionCheckMatchNamePattern } from '../core/functions/functionCheckMatchNamePattern';
+import { checkLayeredArchitecture } from '../core/layers/checkLayeredArchitecture';
+
+import { propertyCheckBeReadonly } from '../core/properties/propertyCheckBeReadonly';
+
+import { sliceCheckBeFreeOfCycles } from '../core/slices/sliceCheckBeFreeOfCycles';
+import { sliceCheckHaveMaxDistanceFromMainSequence } from '../core/slices/sliceCheckHaveMaxDistanceFromMainSequence';
+import type { LocatorData, RuleResult } from '../core/types';
 
 export function setupMatchers() {
   expect.extend({
-    toPass(received: RuleResult | LayeredArchitectureBuilder) {
-      const result = received instanceof LayeredArchitectureBuilder ? received.check() : received;
+    // biome-ignore lint/suspicious/noExplicitAny: Matcher signature
+    toPass(received: any) {
+      let result: RuleResult;
+
+      if (received?.data && received.data.type === 'LayeredArchitecture') {
+        result = checkLayeredArchitecture(received.data);
+      } else {
+        result = received as RuleResult;
+      }
+
       const { pass, message } = result;
       return {
         pass: this.isNot ? !pass : pass,
-        message: pass 
-          ? () => 'Expected rule not to pass' 
-          : () => message()
+        message: pass ? () => 'Expected rule not to pass' : () => message(),
       };
     },
 
-    toResideInFolder(received: ClassLocator, folder: string) {
-      const { pass, message } = received.checkResideInFolder(folder, this.isNot);
+    toResideInFolder(received: LocatorData, folder: string) {
+      let result: RuleResult;
+      if (received.type === 'ClassLocator') {
+        result = classCheckResideInFolder(received, folder, this.isNot);
+      } else {
+        throw new Error(
+          `toResideInFolder matcher does not support ${received.type}`,
+        );
+      }
       return {
-        pass: this.isNot ? !pass : pass,
-        message
+        pass: this.isNot ? !result.pass : result.pass,
+        message: result.message,
       };
     },
 
-    toHaveModifier(received: ClassLocator | FunctionLocator, modifier: string) {
-      const { pass, message } = received.checkHaveModifier(modifier, this.isNot);
+    toHaveModifier(received: LocatorData, modifier: string) {
+      let result: RuleResult;
+      if (received.type === 'ClassLocator') {
+        result = classCheckHaveModifier(received, modifier, this.isNot);
+      } else if (received.type === 'FunctionLocator') {
+        result = functionCheckHaveModifier(received, modifier, this.isNot);
+      } else {
+        throw new Error(
+          `toHaveModifier matcher does not support ${received.type}`,
+        );
+      }
       return {
-        pass: this.isNot ? !pass : pass,
-        message
+        pass: this.isNot ? !result.pass : result.pass,
+        message: result.message,
       };
     },
 
+    toExtendClass(received: LocatorData, className: string) {
+      let result: RuleResult;
+      if (received.type === 'ClassLocator') {
+        result = classCheckExtendClass(received, className, this.isNot);
+      } else {
+        throw new Error(
+          `toExtendClass matcher does not support ${received.type}`,
+        );
+      }
+      return {
+        pass: this.isNot ? !result.pass : result.pass,
+        message: result.message,
+      };
+    },
 
+    toImplementInterface(received: LocatorData, interfaceName: string) {
+      let result: RuleResult;
+      if (received.type === 'ClassLocator') {
+        result = classCheckImplementInterface(
+          received,
+          interfaceName,
+          this.isNot,
+        );
+      } else {
+        throw new Error(
+          `toImplementInterface matcher does not support ${received.type}`,
+        );
+      }
+      return {
+        pass: this.isNot ? !result.pass : result.pass,
+        message: result.message,
+      };
+    },
 
-    toExtendClass(received: ClassLocator, className: string) {
-      const { pass, message } = received.checkExtendClass(className, this.isNot);
+    toHaveExplicitReturnType(received: LocatorData) {
+      let result: RuleResult;
+      if (received.type === 'FunctionLocator') {
+        result = functionCheckHaveExplicitReturnType(received, this.isNot);
+      } else {
+        throw new Error(
+          `toHaveExplicitReturnType matcher does not support ${received.type}`,
+        );
+      }
       return {
-        pass: this.isNot ? !pass : pass,
-        message
+        pass: this.isNot ? !result.pass : result.pass,
+        message: result.message,
       };
     },
 
-    toImplementInterface(received: ClassLocator, interfaceName: string) {
-      const { pass, message } = received.checkImplementInterface(interfaceName, this.isNot);
+    toBeReadonly(received: LocatorData) {
+      let result: RuleResult;
+      if (received.type === 'PropertyLocator') {
+        result = propertyCheckBeReadonly(received, this.isNot);
+      } else {
+        throw new Error(
+          `toBeReadonly matcher does not support ${received.type}`,
+        );
+      }
       return {
-        pass: this.isNot ? !pass : pass,
-        message
+        pass: this.isNot ? !result.pass : result.pass,
+        message: result.message,
       };
     },
 
-    toHaveExplicitReturnType(received: FunctionLocator) {
-      const { pass, message } = received.checkHaveExplicitReturnType(this.isNot);
+    toDependOnFilesInFolder(received: LocatorData, folder: string) {
+      let result: RuleResult;
+      if (received.type === 'FileLocator') {
+        result = checkDependOnFilesInFolder(received, folder, this.isNot);
+      } else {
+        throw new Error(
+          `toDependOnFilesInFolder matcher does not support ${received.type}`,
+        );
+      }
       return {
-        pass: this.isNot ? !pass : pass,
-        message
+        pass: this.isNot ? !result.pass : result.pass,
+        message: result.message,
       };
     },
 
-    toBeReadonly(received: PropertyLocator) {
-      const { pass, message } = received.checkBeReadonly(this.isNot);
+    toBeFreeOfCycles(received: LocatorData) {
+      let result: RuleResult;
+      if (received.type === 'FileLocator') {
+        result = fileCheckBeFreeOfCycles(received, this.isNot);
+      } else if (received.type === 'SliceLocator') {
+        result = sliceCheckBeFreeOfCycles(received, this.isNot);
+      } else {
+        throw new Error(
+          `toBeFreeOfCycles matcher does not support ${received.type}`,
+        );
+      }
       return {
-        pass: this.isNot ? !pass : pass,
-        message
+        pass: this.isNot ? !result.pass : result.pass,
+        message: result.message,
       };
     },
 
-    toDependOnFilesInFolder(received: FileLocator, folder: string) {
-      const { pass, message } = received.checkDependOnFilesInFolder(folder, this.isNot);
+    toMatchNamePattern(received: LocatorData, pattern: string | RegExp) {
+      let result: RuleResult;
+      if (received.type === 'FileLocator') {
+        result = fileCheckMatchNamePattern(received, pattern, this.isNot);
+      } else if (received.type === 'ClassLocator') {
+        result = classCheckMatchNamePattern(received, pattern, this.isNot);
+      } else if (received.type === 'FunctionLocator') {
+        result = functionCheckMatchNamePattern(received, pattern, this.isNot);
+      } else {
+        throw new Error(
+          `toMatchNamePattern matcher does not support ${received.type}`,
+        );
+      }
       return {
-        pass: this.isNot ? !pass : pass,
-        message
+        pass: this.isNot ? !result.pass : result.pass,
+        message: result.message,
       };
     },
 
-    toBeFreeOfCycles(received: FileLocator | SliceLocator) {
-      const { pass, message } = received.checkBeFreeOfCycles(this.isNot);
+    toHaveMaxCyclomaticComplexity(received: LocatorData, max: number) {
+      let result: RuleResult;
+      if (received.type === 'FileLocator') {
+        result = fileCheckHaveMaxCyclomaticComplexity(
+          received,
+          max,
+          this.isNot,
+        );
+      } else if (received.type === 'ClassLocator') {
+        result = classCheckHaveMaxCyclomaticComplexity(
+          received,
+          max,
+          this.isNot,
+        );
+      } else if (received.type === 'FunctionLocator') {
+        result = functionCheckHaveMaxCyclomaticComplexity(
+          received,
+          max,
+          this.isNot,
+        );
+      } else {
+        throw new Error(
+          `toHaveMaxCyclomaticComplexity matcher does not support ${received.type}`,
+        );
+      }
       return {
-        pass: this.isNot ? !pass : pass,
-        message
+        pass: this.isNot ? !result.pass : result.pass,
+        message: result.message,
       };
     },
 
-    toMatchNamePattern(received: FileLocator | ClassLocator | FunctionLocator, pattern: string | RegExp) {
-      const { pass, message } = received.checkMatchNamePattern(pattern, this.isNot);
+    toHaveMinMaintainabilityIndex(received: LocatorData, min: number) {
+      let result: RuleResult;
+      if (received.type === 'FileLocator') {
+        result = fileCheckHaveMinMaintainabilityIndex(
+          received,
+          min,
+          this.isNot,
+        );
+      } else if (received.type === 'FunctionLocator') {
+        result = functionCheckHaveMinMaintainabilityIndex(
+          received,
+          min,
+          this.isNot,
+        );
+      } else {
+        throw new Error(
+          `toHaveMinMaintainabilityIndex matcher does not support ${received.type}`,
+        );
+      }
       return {
-        pass: this.isNot ? !pass : pass,
-        message
+        pass: this.isNot ? !result.pass : result.pass,
+        message: result.message,
+      };
+    },
+
+    toHaveMaxDistanceFromMainSequence(received: LocatorData, max: number) {
+      let result: RuleResult;
+      if (received.type === 'SliceLocator') {
+        result = sliceCheckHaveMaxDistanceFromMainSequence(
+          received,
+          max,
+          this.isNot,
+        );
+      } else {
+        throw new Error(
+          `toHaveMaxDistanceFromMainSequence matcher does not support ${received.type}`,
+        );
+      }
+      return {
+        pass: this.isNot ? !result.pass : result.pass,
+        message: result.message,
+      };
+    },
+
+    toHaveNameMatchingFileName(received: LocatorData) {
+      let result: RuleResult;
+      if (received.type === 'FunctionLocator') {
+        result = functionCheckHaveNameMatchingFileName(received, this.isNot);
+      } else if (received.type === 'ClassLocator') {
+        result = classCheckHaveNameMatchingFileName(received, this.isNot);
+      } else {
+        throw new Error(
+          `toHaveNameMatchingFileName matcher does not support ${received.type}`,
+        );
+      }
+      return {
+        pass: this.isNot ? !result.pass : result.pass,
+        message: result.message,
+      };
+    },
+
+    toHaveMaxExportedFunctions(received: LocatorData, max: number) {
+      let result: RuleResult;
+      if (received.type === 'FileLocator') {
+        result = fileCheckHaveMaxExportedFunctions(received, max, this.isNot);
+      } else {
+        throw new Error(
+          `toHaveMaxExportedFunctions matcher does not support ${received.type}`,
+        );
+      }
+      return {
+        pass: this.isNot ? !result.pass : result.pass,
+        message: result.message,
       };
-    }
+    },
   });
 }
 
 declare module 'vitest' {
+  // biome-ignore lint/suspicious/noExplicitAny: Matcher signature
   interface Assertion<T = any> {
     toPass(): void;
     toResideInFolder(folder: string): void;
-    toHaveModifier(modifier: 'export' | 'default' | 'abstract' | 'async' | 'private' | 'public'): void;
-
+    toHaveModifier(
+      modifier:
+        | 'export'
+        | 'default'
+        | 'abstract'
+        | 'async'
+        | 'private'
+        | 'public',
+    ): void;
     toExtendClass(className: string): void;
     toImplementInterface(interfaceName: string): void;
     toHaveExplicitReturnType(): void;
@@ -109,5 +322,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/test/architecture.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest';
-import { parseProject } from '../src/core/Project';
+import { describe, expect, it } from 'vitest';
+import { parseProject } from '../src/core/project/parseProject';
 import { setupMatchers } from '../src/matchers';
 
 setupMatchers();
@@ -19,15 +19,20 @@ describe('@archest/vitest', () => {
     });
   });
 
-  describe('ClassLocator (Declaration Checks)', () => {
-    it('locators should have export modifier', () => {
-      const locators = project.getClasses({ inFolder: 'core', matchNamePattern: /Locator$/ });
-      expect(locators).toHaveModifier('export');
+  describe('FunctionLocator (Declaration Checks)', () => {
+    it('check functions should have export modifier', () => {
+      const checkFunctions = project.getFunctions({
+        inFolder: 'core',
+        matchNamePattern: /check/i,
+      });
+      expect(checkFunctions).toHaveModifier('export');
     });
 
-    it('Project class should be exported', () => {
-      const projectClasses = project.getClasses({ matchNamePattern: /Project$/ });
-      expect(projectClasses).toHaveModifier('export');
+    it('parseProject function should be exported', () => {
+      const projectFunctions = project.getFunctions({
+        matchNamePattern: /^parseProject$/,
+      });
+      expect(projectFunctions).toHaveModifier('export');
     });
   });
 
@@ -43,17 +48,105 @@ describe('@archest/vitest', () => {
     });
   });
 
-  describe('LayeredArchitectureBuilder', () => {
-    it('core should not depend on matchers layer', () => {
-      const architecture = project.layeredArchitecture()
-        .layer('Core', 'core')
+  describe('Layered Architecture', () => {
+    it('should enforce strict internal layer dependencies', () => {
+      const architecture = project
+        .layeredArchitecture()
+        .layer('Utils', 'core/utils')
+        .layer('Shared', 'core/shared')
+        .layer(
+          'Domains',
+          'core/(classes|files|functions|properties|slices|layers|metrics|project)',
+        )
         .layer('Matchers', 'matchers')
         .layer('Root', 'src'); // src/index.ts is just under src
 
-      const rule = architecture
-        .whereLayer('Matchers').shouldOnlyBeAccessedBy('Core', 'Root');
+      // Utils should only be accessed by higher layers
+      expect(
+        architecture
+          .whereLayer('Utils')
+          .shouldOnlyBeAccessedBy('Shared', 'Domains', 'Matchers', 'Root'),
+      ).toPass();
 
-      expect(rule).toPass();
+      // Shared should only be accessed by Domains and above
+      expect(
+        architecture
+          .whereLayer('Shared')
+          .shouldOnlyBeAccessedBy('Domains', 'Matchers', 'Root'),
+      ).toPass();
+
+      // Domains should only be accessed by Matchers and Root
+      expect(
+        architecture
+          .whereLayer('Domains')
+          .shouldOnlyBeAccessedBy('Matchers', 'Root'),
+      ).toPass();
+
+      // Matchers should only be accessed by Root
+      expect(
+        architecture.whereLayer('Matchers').shouldOnlyBeAccessedBy('Root'),
+      ).toPass();
+    });
+  });
+
+  describe('Structural Metrics', () => {
+    it('core files should have a reasonable cyclomatic complexity', () => {
+      const coreFiles = project.getFiles({ inFolder: 'core' });
+      // The max complexity is arbitrary for this test, but 200 should pass
+      expect(coreFiles).toHaveMaxCyclomaticComplexity(200);
+    });
+
+    it('core files should have a minimum maintainability index', () => {
+      const coreFiles = project.getFiles({ inFolder: 'core' });
+      // A minimum index of 5 should pass for our small files
+      expect(coreFiles).toHaveMinMaintainabilityIndex(5);
+    });
+
+    it('slices should maintain a reasonable distance from the main sequence', () => {
+      const slices = project.getSlices('src/(.*)');
+      // Distance is between 0 and 1, we expect a reasonable balance < 0.8
+      expect(slices).toHaveMaxDistanceFromMainSequence(0.8);
+    });
+  });
+
+  describe('Granular Folder Structure', () => {
+    it('functions should have a name matching their filename', () => {
+      const coreFunctions = project.getFunctions({
+        inFolder: 'core',
+        isTopLevel: true,
+      });
+      expect(coreFunctions).toHaveNameMatchingFileName();
+    });
+
+    it('classes should have a name matching their filename', () => {
+      const coreClasses = project.getClasses({ inFolder: 'core' });
+      expect(coreClasses).toHaveNameMatchingFileName();
+    });
+
+    it('files should have a maximum of 1 exported function', () => {
+      // Exclude index.ts, types.ts, and testUtils.ts which have different export rules
+      const implementationFiles = project.getFiles({
+        inFolder: 'core',
+        matchNamePattern: /^(?!.*(types|index|testUtils)\.ts$).*\.ts$/,
+      });
+      expect(implementationFiles).toHaveMaxExportedFunctions(1);
+    });
+  });
+
+  describe('Shared Abstraction Layer', () => {
+    it('shared abstraction functions should be prefixed with sharedCheck', () => {
+      const sharedFunctions = project.getFunctions({
+        inFolder: 'core/shared',
+        isTopLevel: true,
+      });
+      expect(sharedFunctions).toMatchNamePattern(/^sharedCheck/);
+    });
+
+    it('shared abstraction files should not depend on domain logic', () => {
+      const sharedFiles = project.getFiles({ inFolder: 'core/shared' });
+      expect(sharedFiles).not.toDependOnFilesInFolder('classes');
+      expect(sharedFiles).not.toDependOnFilesInFolder('functions');
+      expect(sharedFiles).not.toDependOnFilesInFolder('files');
     });
   });
 });

package/tsconfig.json

@@ -13,5 +13,6 @@
     "forceConsistentCasingInFileNames": true,
     "outDir": "dist"
   },
-  "include": ["src/**/*"]
+  "include": ["src/**/*"],
+  "exclude": ["src/**/*.test.ts", "src/core/testUtils.ts"]
 }

package/vite.config.ts

@@ -1,6 +1,6 @@
+import { resolve } from 'node:path';
 import { defineConfig } from 'vite';
 import dts from 'vite-plugin-dts';
-import { resolve } from 'path';
 
 export default defineConfig({
   build: {
@@ -10,7 +10,7 @@ export default defineConfig({
       fileName: (format) => `index.${format === 'es' ? 'mjs' : 'js'}`,
     },
     rollupOptions: {
-      external: ['typescript', 'vitest', 'path', 'fs'],
+      external: ['typescript', 'vitest', 'path', 'fs', 'node:path', 'node:fs'],
     },
     sourcemap: true,
   },

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

@@ -1,20 +0,0 @@
-import { RuleResult } from './types';
-import * as ts from 'typescript';
-export interface ClassQueryOptions {
-    inFolder?: string;
-    matchNamePattern?: string | RegExp;
-    withDecorator?: string;
-    extending?: string;
-    implementing?: string;
-    havingModifier?: string;
-}
-export declare class ClassLocator {
-    private program;
-    readonly classes: ts.ClassDeclaration[];
-    constructor(classes: ts.ClassDeclaration[], program: ts.Program, options?: ClassQueryOptions);
-    checkResideInFolder(targetFolder: string, isNot: boolean): RuleResult;
-    checkMatchNamePattern(pattern: string | RegExp, isNot: boolean): RuleResult;
-    checkExtendClass(className: string, isNot: boolean): RuleResult;
-    checkImplementInterface(interfaceName: string, isNot: boolean): RuleResult;
-    checkHaveModifier(modifierStr: string, isNot: boolean): RuleResult;
-}

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

@@ -1,15 +0,0 @@
-import { RuleResult } from './types';
-import * as ts from 'typescript';
-export interface FileQueryOptions {
-    inFolder?: string;
-    matchNamePattern?: string | RegExp;
-}
-export declare class FileLocator {
-    private program;
-    readonly files: ts.SourceFile[];
-    constructor(sourceFiles: ts.SourceFile[], program: ts.Program, options?: FileQueryOptions);
-    private getFileDependencies;
-    checkDependOnFilesInFolder(targetFolder: string, isNot: boolean): RuleResult;
-    checkBeFreeOfCycles(isNot: boolean): RuleResult;
-    checkMatchNamePattern(pattern: string | RegExp, isNot: boolean): RuleResult;
-}

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

@@ -1,15 +0,0 @@
-import { RuleResult } from './types';
-import * as ts from 'typescript';
-export interface FunctionQueryOptions {
-    inFolder?: string;
-    matchNamePattern?: string | RegExp;
-    isTopLevel?: boolean;
-}
-export declare class FunctionLocator {
-    private program;
-    readonly functions: ts.FunctionLikeDeclaration[];
-    constructor(functions: ts.FunctionLikeDeclaration[], program: ts.Program, options?: FunctionQueryOptions);
-    checkHaveModifier(modifierStr: string, isNot: boolean): RuleResult;
-    checkHaveExplicitReturnType(isNot: boolean): RuleResult;
-    checkMatchNamePattern(pattern: string | RegExp, isNot: boolean): RuleResult;
-}

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

@@ -1,23 +0,0 @@
-import { RuleResult } from './types';
-import * as ts from 'typescript';
-export declare class LayeredArchitectureBuilder {
-    program: ts.Program;
-    private files;
-    private layers;
-    private assertions;
-    constructor(files: ts.SourceFile[], program: ts.Program);
-    layer(name: string, folderPattern: string): this;
-    whereLayer(name: string): LayerAssertionBuilder;
-    addAssertion(assertion: (files: ts.SourceFile[]) => string[]): void;
-    getFiles(): ts.SourceFile[];
-    getLayerPattern(name: string): string;
-    getFileDependencies(sourceFile: ts.SourceFile): string[];
-    check(): RuleResult;
-}
-export declare class LayerAssertionBuilder {
-    private parent;
-    private targetLayer;
-    constructor(parent: LayeredArchitectureBuilder, targetLayer: string);
-    shouldNotBeAccessedByAnyLayer(): LayeredArchitectureBuilder;
-    shouldOnlyBeAccessedBy(...allowedLayers: string[]): LayeredArchitectureBuilder;
-}

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

@@ -1,20 +0,0 @@
-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 declare class Project {
-    private program;
-    private typeChecker;
-    constructor(options?: {
-        tsConfigFilePath?: string;
-    });
-    getFiles(options?: FileQueryOptions): FileLocator;
-    getClasses(options?: ClassQueryOptions): ClassLocator;
-    layeredArchitecture(): LayeredArchitectureBuilder;
-    getFunctions(options?: FunctionQueryOptions): FunctionLocator;
-    getProperties(options?: PropertyQueryOptions): PropertyLocator;
-    getSlices(pattern: string): SliceLocator;
-}
-export declare function parseProject(tsConfigFilePath?: string): Project;

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

@@ -1,12 +0,0 @@
-import { RuleResult } from './types';
-import * as ts from 'typescript';
-export interface PropertyQueryOptions {
-    inFolder?: string;
-    matchNamePattern?: string | RegExp;
-}
-export declare class PropertyLocator {
-    private program;
-    readonly properties: ts.PropertyDeclaration[];
-    constructor(properties: ts.PropertyDeclaration[], program: ts.Program, options?: PropertyQueryOptions);
-    checkBeReadonly(isNot: boolean): RuleResult;
-}