@cloud-ru/ft-deps-validator 1.1.1 → 1.1.2-preview-8996d18.0

package/README.md

@@ -1,6 +1,6 @@
 # @cloud-ru/ft-deps-validator
 
-Validator for unused, missing or wrong version dependencies in monorepo's packages.
+Validator for unused, missing or wrong version dependencies in monorepo's packages or regular repositories.
 
 ## Installation
 
@@ -12,22 +12,24 @@ npm i @cloud-ru/ft-deps-validator
 
 ### Basic usage (via npx)
 
-Run from the root of your monorepo:
+Run from the root of your repository:
 
 ```bash
 npx @cloud-ru/ft-deps-validator
 ```
 
-This will check all packages in the `packages/*` directory relative to the current working directory.
+The package automatically detects if it's a monorepo or a regular repository:
+- **Monorepo**: If `packages` folder exists in the current directory, it will check all packages in `packages/*`
+- **Regular repository**: If `packages` folder doesn't exist, it will check the current directory as a single package
 
 ### Specify working directory
 
 If you need to run from a different location:
 
 ```bash
-npx @cloud-ru/ft-deps-validator --cwd /path/to/your/monorepo
+npx @cloud-ru/ft-deps-validator --cwd /path/to/your/repo
 # or using alias
-npx @cloud-ru/ft-deps-validator -d /path/to/your/monorepo
+npx @cloud-ru/ft-deps-validator -d /path/to/your/repo
 ```
 
 ### Custom packages folder pattern
@@ -40,12 +42,30 @@ npx @cloud-ru/ft-deps-validator --rootPackagesFolderPattern "apps/*"
 npx @cloud-ru/ft-deps-validator -p "apps/*"
 ```
 
-### Combined options
-
-```bash
-npx @cloud-ru/ft-deps-validator --cwd /path/to/monorepo --rootPackagesFolderPattern "packages/*"
+### Configuration file
+
+You can create a `deps-validator.config.json` file in the root of your repository to configure the validator:
+
+```json
+{
+  "rootPackagesFolderPattern": "packages/*",
+  "ignoredPackagesFolderFiles": ["packages/tsconfig.cjs.json"],
+  "ignorePatterns": ["dist", "__tests__"],
+  "ignoreMatches": ["react", "react-dom"],
+  "packages": {
+    "package-name": {
+      "ignorePatterns": ["build"],
+      "ignoreMatches": ["@some/package"]
+    }
+  }
+}
 ```
 
+Configuration priority (highest to lowest):
+1. CLI arguments
+2. Configuration file
+3. Default values
+
 ### Ignore specific patterns
 
 ```bash
@@ -61,11 +81,10 @@ npx @cloud-ru/ft-deps-validator --ignoreMatches "react" "react-dom"
 ## Options
 
 - `--cwd, -d` - Working directory (default: current working directory)
-- `--rootPackagesFolderPattern, -p` - Folder containing packages (glob pattern, e.g., "packages/*" or "apps/*")
-- `--prefix` - Specify monorepo prefix (if skipped will try to find automatically)
-- `--ignoredPackagesFolderFiles` - Specify one or more paths that should be ignored in packages folder
+- `--rootPackagesFolderPattern, -p` - Folder containing packages (glob pattern, e.g., "packages/*" or "apps/*"). If not specified, automatically detects monorepo by checking for `packages` folder
+- `--ignoredPackagesFolderFiles` - Specify one or more paths that should be ignored in packages folder (default: `['packages/tsconfig.cjs.json', 'packages/tsconfig.esm.json']`)
 - `--ignorePatterns` - Specify one or more directories names that should be ignored (default: `['stories', 'dist', '__tests__', '__e2e__']`)
-- `--ignoreMatches` - Specify one or more packages that should be ignored
+- `--ignoreMatches` - Specify one or more packages that should be ignored (default: includes `react`, `react-dom`, `react-docgen-typescript`, and several figma-tokens packages)
 - `--help, -h` - Show help
 - `--version, -v` - Show version
 
@@ -73,5 +92,5 @@ npx @cloud-ru/ft-deps-validator --ignoreMatches "react" "react-dom"
 
 1. **Unused dependencies** - Dependencies that are declared but not used in the code
 2. **Missing dependencies** - Dependencies that are used but not declared in package.json
-3. **Wrong versions** - Internal packages with incorrect version numbers
-4. **Internal packages in devDependencies** - Internal packages that should be in dependencies, not devDependencies
+3. **Wrong versions** (monorepo only) - Internal packages with incorrect version numbers
+4. **Internal packages in devDependencies** (monorepo only) - Internal packages that should be in dependencies, not devDependencies

package/dist/cjs/Checker/MonorepoChecker.d.ts

@@ -0,0 +1,10 @@
+import { MonorepoConfig } from '../Config';
+import { RepoChecker } from './RepoChecker';
+export declare class MonorepoChecker extends RepoChecker {
+    private actualVersions;
+    constructor(config: MonorepoConfig);
+    protected checkFolder(path: string): Promise<Partial<Pick<import("depcheck").Results, "dependencies" | "missing"> & {
+        wrongVersions: string[];
+        internalAsDev: string[];
+    }>>;
+}

package/dist/cjs/Checker/MonorepoChecker.js

@@ -0,0 +1,57 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonorepoChecker = void 0;
+const readPackageJsonFile_1 = require("../utils/readPackageJsonFile");
+const RepoChecker_1 = require("./RepoChecker");
+class MonorepoChecker extends RepoChecker_1.RepoChecker {
+    constructor(config) {
+        super(config);
+        this.actualVersions = {};
+        this.config.getFolders().reduce((acc, folder) => {
+            const pkg = (0, readPackageJsonFile_1.readPackageJsonFileSync)(folder);
+            acc[pkg.name] = pkg.version;
+            return acc;
+        }, this.actualVersions);
+    }
+    checkFolder(path) {
+        const _super = Object.create(null, {
+            checkFolder: { get: () => super.checkFolder }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const [result, pkg] = yield Promise.all([_super.checkFolder.call(this, path), (0, readPackageJsonFile_1.readPackageJsonFile)(path)]);
+            for (const [dep, version] of Object.entries(pkg.dependencies)) {
+                const actualVersion = this.actualVersions[dep];
+                if (actualVersion !== version) {
+                    const message = `"${dep}" has wrong version "${version}", but need "${actualVersion}".`;
+                    if (result.wrongVersions) {
+                        result.wrongVersions.push();
+                    }
+                    else {
+                        result.wrongVersions = [message];
+                    }
+                }
+            }
+            for (const devDep of Object.keys(pkg.devDependencies)) {
+                if (this.actualVersions[devDep]) {
+                    if (result.internalAsDev) {
+                        result.internalAsDev.push(devDep);
+                    }
+                    else {
+                        result.internalAsDev = [devDep];
+                    }
+                }
+            }
+            return result;
+        });
+    }
+}
+exports.MonorepoChecker = MonorepoChecker;

package/dist/cjs/Checker/RepoChecker.d.ts

@@ -0,0 +1,8 @@
+import { RepoConfig } from '../Config';
+import { CheckState, Report } from '../Report';
+export declare class RepoChecker {
+    protected config: RepoConfig;
+    constructor(config: RepoConfig);
+    check(): Promise<Report>;
+    protected checkFolder(path: string): Promise<CheckState>;
+}

package/dist/cjs/Checker/RepoChecker.js

@@ -0,0 +1,36 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepoChecker = void 0;
+const depcheck_1 = __importDefault(require("depcheck"));
+const Report_1 = require("../Report");
+class RepoChecker {
+    constructor(config) {
+        this.config = config;
+    }
+    check() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const folders = this.config.getFolders();
+            const report = new Report_1.Report();
+            yield Promise.all(folders.map(folder => this.checkFolder(folder).then(result => report.add(folder, result))));
+            return report;
+        });
+    }
+    checkFolder(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, depcheck_1.default)(path, this.config.getFolderOptions(path));
+        });
+    }
+}
+exports.RepoChecker = RepoChecker;

package/dist/cjs/Checker/__tests__/MonorepoChecker.spec.js

@@ -0,0 +1,305 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const depcheck_1 = __importDefault(require("depcheck"));
+const vitest_1 = require("vitest");
+const readPackageJsonFile_1 = require("../../utils/readPackageJsonFile");
+const MonorepoChecker_1 = require("../MonorepoChecker");
+vitest_1.vi.mock('depcheck', () => ({
+    default: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock('../../utils/readPackageJsonFile', () => ({
+    readPackageJsonFile: vitest_1.vi.fn(),
+    readPackageJsonFileSync: vitest_1.vi.fn(),
+}));
+(0, vitest_1.describe)('MonorepoChecker', () => {
+    let mockConfig;
+    const mockDepcheck = vitest_1.vi.mocked(depcheck_1.default);
+    const mockReadPackageJsonFile = vitest_1.vi.mocked(readPackageJsonFile_1.readPackageJsonFile);
+    const mockReadPackageJsonFileSync = vitest_1.vi.mocked(readPackageJsonFile_1.readPackageJsonFileSync);
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        mockConfig = {
+            getFolders: vitest_1.vi.fn(),
+            getFolderOptions: vitest_1.vi.fn(),
+        };
+    });
+    (0, vitest_1.describe)('check', () => {
+        (0, vitest_1.beforeEach)(() => {
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue([]);
+        });
+        (0, vitest_1.it)('should add wrongVersions when dependency version does not match', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1', '/test/folder2'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            mockReadPackageJsonFileSync
+                .mockReturnValueOnce({
+                name: '@test/package1',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: {},
+            })
+                .mockReturnValueOnce({
+                name: '@test/package2',
+                version: '2.0.0',
+                dependencies: {},
+                devDependencies: {},
+            });
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            mockReadPackageJsonFile.mockResolvedValue({
+                name: 'test-package',
+                version: '1.0.0',
+                dependencies: { '@test/package1': '1.1.0' },
+                devDependencies: {},
+            });
+            vitest_1.vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker_1.MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            (0, vitest_1.expect)(exitCode).toBe(1);
+        }));
+        (0, vitest_1.it)('should not add wrongVersions when dependency version matches', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            mockReadPackageJsonFileSync.mockReturnValue({
+                name: '@test/package1',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: {},
+            });
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            mockReadPackageJsonFile.mockResolvedValue({
+                name: 'test-package',
+                version: '1.0.0',
+                dependencies: { '@test/package1': '1.0.0' },
+                devDependencies: {},
+            });
+            vitest_1.vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker_1.MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            (0, vitest_1.expect)(exitCode).toBe(0);
+        }));
+        (0, vitest_1.it)('should add to existing wrongVersions array', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            mockReadPackageJsonFileSync.mockReturnValue({
+                name: '@test/package1',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: {},
+            });
+            const checkState = {
+                dependencies: [],
+                wrongVersions: ['existing error'],
+            };
+            mockDepcheck.mockResolvedValue(checkState);
+            mockReadPackageJsonFile.mockResolvedValue({
+                name: 'test-package',
+                version: '1.0.0',
+                dependencies: { '@test/package1': '1.1.0' },
+                devDependencies: {},
+            });
+            vitest_1.vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker_1.MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            (0, vitest_1.expect)(exitCode).toBe(1);
+        }));
+        (0, vitest_1.it)('should add internalAsDev when internal package is in devDependencies', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            mockReadPackageJsonFileSync.mockReturnValue({
+                name: '@test/package1',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: {},
+            });
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            mockReadPackageJsonFile.mockResolvedValue({
+                name: 'test-package',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: { '@test/package1': '1.0.0' },
+            });
+            vitest_1.vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker_1.MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            (0, vitest_1.expect)(exitCode).toBe(1);
+        }));
+        (0, vitest_1.it)('should not add internalAsDev when package is not internal', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            mockReadPackageJsonFileSync.mockReturnValue({
+                name: '@test/package1',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: {},
+            });
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            mockReadPackageJsonFile.mockResolvedValue({
+                name: 'test-package',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: { 'external-package': '1.0.0' },
+            });
+            vitest_1.vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker_1.MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            (0, vitest_1.expect)(exitCode).toBe(0);
+        }));
+        (0, vitest_1.it)('should add to existing internalAsDev array', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            mockReadPackageJsonFileSync.mockReturnValue({
+                name: '@test/package1',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: {},
+            });
+            const checkState = {
+                dependencies: [],
+                internalAsDev: ['existing-package'],
+            };
+            mockDepcheck.mockResolvedValue(checkState);
+            mockReadPackageJsonFile.mockResolvedValue({
+                name: 'test-package',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: { '@test/package1': '1.0.0' },
+            });
+            vitest_1.vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker_1.MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            (0, vitest_1.expect)(exitCode).toBe(1);
+        }));
+        (0, vitest_1.it)('should handle multiple wrong versions', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1', '/test/folder2'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            mockReadPackageJsonFileSync
+                .mockReturnValueOnce({
+                name: '@test/package1',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: {},
+            })
+                .mockReturnValueOnce({
+                name: '@test/package2',
+                version: '2.0.0',
+                dependencies: {},
+                devDependencies: {},
+            });
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            mockReadPackageJsonFile.mockResolvedValue({
+                name: 'test-package',
+                version: '1.0.0',
+                dependencies: {
+                    '@test/package1': '1.1.0',
+                    '@test/package2': '2.1.0',
+                },
+                devDependencies: {},
+            });
+            vitest_1.vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker_1.MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            (0, vitest_1.expect)(exitCode).toBe(1);
+        }));
+        (0, vitest_1.it)('should handle both wrongVersions and internalAsDev', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1', '/test/folder2'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            mockReadPackageJsonFileSync
+                .mockReturnValueOnce({
+                name: '@test/package1',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: {},
+            })
+                .mockReturnValueOnce({
+                name: '@test/package2',
+                version: '2.0.0',
+                dependencies: {},
+                devDependencies: {},
+            });
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            mockReadPackageJsonFile.mockResolvedValue({
+                name: 'test-package',
+                version: '1.0.0',
+                dependencies: { '@test/package1': '1.1.0' },
+                devDependencies: { '@test/package2': '2.0.0' },
+            });
+            vitest_1.vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker_1.MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            (0, vitest_1.expect)(exitCode).toBe(1);
+        }));
+        (0, vitest_1.it)('should add wrongVersions for external packages (when actualVersion is undefined)', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            mockReadPackageJsonFileSync.mockReturnValue({
+                name: '@test/package1',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: {},
+            });
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            mockReadPackageJsonFile.mockResolvedValue({
+                name: 'test-package',
+                version: '1.0.0',
+                dependencies: { 'external-package': '1.0.0' },
+                devDependencies: {},
+            });
+            vitest_1.vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker_1.MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            // Текущая реализация добавляет ошибку для внешних пакетов,
+            // так как actualVersion === undefined, и условие undefined !== "1.0.0" будет true
+            const exitCode = report.printResultAndGetExitCode();
+            (0, vitest_1.expect)(exitCode).toBe(1);
+        }));
+        (0, vitest_1.it)('should handle empty dependencies and devDependencies', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            mockReadPackageJsonFileSync.mockReturnValue({
+                name: '@test/package1',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: {},
+            });
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            mockReadPackageJsonFile.mockResolvedValue({
+                name: 'test-package',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: {},
+            });
+            vitest_1.vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker_1.MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            (0, vitest_1.expect)(exitCode).toBe(0);
+        }));
+    });
+});

package/dist/cjs/Checker/__tests__/RepoChecker.spec.js

@@ -0,0 +1,116 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const depcheck_1 = __importDefault(require("depcheck"));
+const vitest_1 = require("vitest");
+const RepoChecker_1 = require("../RepoChecker");
+vitest_1.vi.mock('depcheck', () => ({
+    default: vitest_1.vi.fn(),
+}));
+(0, vitest_1.describe)('RepoChecker', () => {
+    let mockConfig;
+    const mockDepcheck = vitest_1.vi.mocked(depcheck_1.default);
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        mockConfig = {
+            getFolders: vitest_1.vi.fn(),
+            getFolderOptions: vitest_1.vi.fn(),
+        };
+    });
+    (0, vitest_1.describe)('constructor', () => {
+        (0, vitest_1.it)('should initialize with config', () => {
+            const checker = new RepoChecker_1.RepoChecker(mockConfig);
+            (0, vitest_1.expect)(checker).toBeInstanceOf(RepoChecker_1.RepoChecker);
+        });
+    });
+    (0, vitest_1.describe)('check', () => {
+        (0, vitest_1.it)('should call getFolders on config', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            const checker = new RepoChecker_1.RepoChecker(mockConfig);
+            yield checker.check();
+            (0, vitest_1.expect)(mockConfig.getFolders).toHaveBeenCalledTimes(1);
+        }));
+        (0, vitest_1.it)('should call checkFolder for each folder', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1', '/test/folder2'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            const checkState1 = { dependencies: ['dep1'] };
+            const checkState2 = { dependencies: ['dep2'] };
+            mockDepcheck.mockResolvedValueOnce(checkState1).mockResolvedValueOnce(checkState2);
+            vitest_1.vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new RepoChecker_1.RepoChecker(mockConfig);
+            yield checker.check();
+            (0, vitest_1.expect)(mockDepcheck).toHaveBeenCalledTimes(2);
+        }));
+        (0, vitest_1.it)('should call getFolderOptions for each folder with correct path', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1', '/test/folder2'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            const options1 = { ignoreBinPackage: false };
+            const options2 = { ignoreBinPackage: false };
+            vitest_1.vi.mocked(mockConfig.getFolderOptions)
+                .mockReturnValueOnce(options1)
+                .mockReturnValueOnce(options2);
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            const checker = new RepoChecker_1.RepoChecker(mockConfig);
+            yield checker.check();
+            (0, vitest_1.expect)(mockConfig.getFolderOptions).toHaveBeenCalledWith('/test/folder1');
+            (0, vitest_1.expect)(mockConfig.getFolderOptions).toHaveBeenCalledWith('/test/folder2');
+        }));
+        (0, vitest_1.it)('should call depcheck with correct path and options', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            const options = { ignoreBinPackage: false, skipMissing: false };
+            vitest_1.vi.mocked(mockConfig.getFolderOptions).mockReturnValue(options);
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            const checker = new RepoChecker_1.RepoChecker(mockConfig);
+            yield checker.check();
+            (0, vitest_1.expect)(mockDepcheck).toHaveBeenCalledWith('/test/folder1', options);
+        }));
+        (0, vitest_1.it)('should add results to report for each folder', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1', '/test/folder2'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            const checkState1 = { dependencies: ['dep1'] };
+            const checkState2 = { dependencies: ['dep2'] };
+            mockDepcheck.mockResolvedValueOnce(checkState1).mockResolvedValueOnce(checkState2);
+            vitest_1.vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new RepoChecker_1.RepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            (0, vitest_1.expect)(exitCode).toBe(1);
+        }));
+        (0, vitest_1.it)('should return Report instance', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            vitest_1.vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new RepoChecker_1.RepoChecker(mockConfig);
+            const report = yield checker.check();
+            (0, vitest_1.expect)(report).toBeDefined();
+            (0, vitest_1.expect)(report.printResultAndGetExitCode).toBeDefined();
+        }));
+        (0, vitest_1.it)('should handle empty folders array', () => __awaiter(void 0, void 0, void 0, function* () {
+            vitest_1.vi.mocked(mockConfig.getFolders).mockReturnValue([]);
+            const checker = new RepoChecker_1.RepoChecker(mockConfig);
+            const report = yield checker.check();
+            (0, vitest_1.expect)(mockDepcheck).not.toHaveBeenCalled();
+            const exitCode = report.printResultAndGetExitCode();
+            (0, vitest_1.expect)(exitCode).toBe(0);
+        }));
+    });
+});

package/dist/cjs/Checker/index.d.ts

@@ -0,0 +1,2 @@
+export { RepoChecker } from './RepoChecker';
+export { MonorepoChecker } from './MonorepoChecker';

package/dist/cjs/Checker/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonorepoChecker = exports.RepoChecker = void 0;
+var RepoChecker_1 = require("./RepoChecker");
+Object.defineProperty(exports, "RepoChecker", { enumerable: true, get: function () { return RepoChecker_1.RepoChecker; } });
+var MonorepoChecker_1 = require("./MonorepoChecker");
+Object.defineProperty(exports, "MonorepoChecker", { enumerable: true, get: function () { return MonorepoChecker_1.MonorepoChecker; } });

package/dist/cjs/Config/MonorepoConfig.d.ts

@@ -0,0 +1,12 @@
+import { Options } from 'depcheck';
+import { MonorepoEnvType } from '../types';
+import { RepoConfig } from './RepoConfig';
+export declare class MonorepoConfig extends RepoConfig {
+    private rootPackagesFolderPattern;
+    private ignoredPackagesFolderFiles;
+    private packages;
+    private folders?;
+    constructor(env: MonorepoEnvType);
+    getFolderOptions(folderPath: string): Options;
+    getFolders(): string[];
+}