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

package/dist/esm/Checker/MonorepoChecker.js

@@ -0,0 +1,53 @@
+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());
+    });
+};
+import { readPackageJsonFile, readPackageJsonFileSync } from '../utils/readPackageJsonFile';
+import { RepoChecker } from './RepoChecker';
+export class MonorepoChecker extends RepoChecker {
+    constructor(config) {
+        super(config);
+        this.actualVersions = {};
+        this.config.getFolders().reduce((acc, folder) => {
+            const pkg = 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), 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;
+        });
+    }
+}

package/dist/esm/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/esm/Checker/RepoChecker.js

@@ -0,0 +1,29 @@
+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());
+    });
+};
+import depcheck from 'depcheck';
+import { Report } from '../Report';
+export 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();
+            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 depcheck(path, this.config.getFolderOptions(path));
+        });
+    }
+}

package/dist/esm/Checker/__tests__/MonorepoChecker.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,300 @@
+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());
+    });
+};
+import depcheck from 'depcheck';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { readPackageJsonFile, readPackageJsonFileSync } from '../../utils/readPackageJsonFile';
+import { MonorepoChecker } from '../MonorepoChecker';
+vi.mock('depcheck', () => ({
+    default: vi.fn(),
+}));
+vi.mock('../../utils/readPackageJsonFile', () => ({
+    readPackageJsonFile: vi.fn(),
+    readPackageJsonFileSync: vi.fn(),
+}));
+describe('MonorepoChecker', () => {
+    let mockConfig;
+    const mockDepcheck = vi.mocked(depcheck);
+    const mockReadPackageJsonFile = vi.mocked(readPackageJsonFile);
+    const mockReadPackageJsonFileSync = vi.mocked(readPackageJsonFileSync);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockConfig = {
+            getFolders: vi.fn(),
+            getFolderOptions: vi.fn(),
+        };
+    });
+    describe('check', () => {
+        beforeEach(() => {
+            vi.mocked(mockConfig.getFolders).mockReturnValue([]);
+        });
+        it('should add wrongVersions when dependency version does not match', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1', '/test/folder2'];
+            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: {},
+            });
+            vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            expect(exitCode).toBe(1);
+        }));
+        it('should not add wrongVersions when dependency version matches', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            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: {},
+            });
+            vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            expect(exitCode).toBe(0);
+        }));
+        it('should add to existing wrongVersions array', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            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: {},
+            });
+            vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            expect(exitCode).toBe(1);
+        }));
+        it('should add internalAsDev when internal package is in devDependencies', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            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' },
+            });
+            vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            expect(exitCode).toBe(1);
+        }));
+        it('should not add internalAsDev when package is not internal', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            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' },
+            });
+            vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            expect(exitCode).toBe(0);
+        }));
+        it('should add to existing internalAsDev array', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            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' },
+            });
+            vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            expect(exitCode).toBe(1);
+        }));
+        it('should handle multiple wrong versions', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1', '/test/folder2'];
+            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: {},
+            });
+            vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            expect(exitCode).toBe(1);
+        }));
+        it('should handle both wrongVersions and internalAsDev', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1', '/test/folder2'];
+            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' },
+            });
+            vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            expect(exitCode).toBe(1);
+        }));
+        it('should add wrongVersions for external packages (when actualVersion is undefined)', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            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: {},
+            });
+            vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            // Текущая реализация добавляет ошибку для внешних пакетов,
+            // так как actualVersion === undefined, и условие undefined !== "1.0.0" будет true
+            const exitCode = report.printResultAndGetExitCode();
+            expect(exitCode).toBe(1);
+        }));
+        it('should handle empty dependencies and devDependencies', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            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: {},
+            });
+            vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new MonorepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            expect(exitCode).toBe(0);
+        }));
+    });
+});

package/dist/esm/Checker/__tests__/RepoChecker.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,111 @@
+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());
+    });
+};
+import depcheck from 'depcheck';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { RepoChecker } from '../RepoChecker';
+vi.mock('depcheck', () => ({
+    default: vi.fn(),
+}));
+describe('RepoChecker', () => {
+    let mockConfig;
+    const mockDepcheck = vi.mocked(depcheck);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockConfig = {
+            getFolders: vi.fn(),
+            getFolderOptions: vi.fn(),
+        };
+    });
+    describe('constructor', () => {
+        it('should initialize with config', () => {
+            const checker = new RepoChecker(mockConfig);
+            expect(checker).toBeInstanceOf(RepoChecker);
+        });
+    });
+    describe('check', () => {
+        it('should call getFolders on config', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            const checker = new RepoChecker(mockConfig);
+            yield checker.check();
+            expect(mockConfig.getFolders).toHaveBeenCalledTimes(1);
+        }));
+        it('should call checkFolder for each folder', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1', '/test/folder2'];
+            vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            const checkState1 = { dependencies: ['dep1'] };
+            const checkState2 = { dependencies: ['dep2'] };
+            mockDepcheck.mockResolvedValueOnce(checkState1).mockResolvedValueOnce(checkState2);
+            vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new RepoChecker(mockConfig);
+            yield checker.check();
+            expect(mockDepcheck).toHaveBeenCalledTimes(2);
+        }));
+        it('should call getFolderOptions for each folder with correct path', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1', '/test/folder2'];
+            vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            const options1 = { ignoreBinPackage: false };
+            const options2 = { ignoreBinPackage: false };
+            vi.mocked(mockConfig.getFolderOptions)
+                .mockReturnValueOnce(options1)
+                .mockReturnValueOnce(options2);
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            const checker = new RepoChecker(mockConfig);
+            yield checker.check();
+            expect(mockConfig.getFolderOptions).toHaveBeenCalledWith('/test/folder1');
+            expect(mockConfig.getFolderOptions).toHaveBeenCalledWith('/test/folder2');
+        }));
+        it('should call depcheck with correct path and options', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            const options = { ignoreBinPackage: false, skipMissing: false };
+            vi.mocked(mockConfig.getFolderOptions).mockReturnValue(options);
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            const checker = new RepoChecker(mockConfig);
+            yield checker.check();
+            expect(mockDepcheck).toHaveBeenCalledWith('/test/folder1', options);
+        }));
+        it('should add results to report for each folder', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1', '/test/folder2'];
+            vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            const checkState1 = { dependencies: ['dep1'] };
+            const checkState2 = { dependencies: ['dep2'] };
+            mockDepcheck.mockResolvedValueOnce(checkState1).mockResolvedValueOnce(checkState2);
+            vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new RepoChecker(mockConfig);
+            const report = yield checker.check();
+            const exitCode = report.printResultAndGetExitCode();
+            expect(exitCode).toBe(1);
+        }));
+        it('should return Report instance', () => __awaiter(void 0, void 0, void 0, function* () {
+            const folders = ['/test/folder1'];
+            vi.mocked(mockConfig.getFolders).mockReturnValue(folders);
+            const checkState = { dependencies: [] };
+            mockDepcheck.mockResolvedValue(checkState);
+            vi.mocked(mockConfig.getFolderOptions).mockReturnValue({});
+            const checker = new RepoChecker(mockConfig);
+            const report = yield checker.check();
+            expect(report).toBeDefined();
+            expect(report.printResultAndGetExitCode).toBeDefined();
+        }));
+        it('should handle empty folders array', () => __awaiter(void 0, void 0, void 0, function* () {
+            vi.mocked(mockConfig.getFolders).mockReturnValue([]);
+            const checker = new RepoChecker(mockConfig);
+            const report = yield checker.check();
+            expect(mockDepcheck).not.toHaveBeenCalled();
+            const exitCode = report.printResultAndGetExitCode();
+            expect(exitCode).toBe(0);
+        }));
+    });
+});

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

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

package/dist/esm/Checker/index.js

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

package/dist/esm/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[];
+}

package/dist/esm/Config/MonorepoConfig.js

@@ -0,0 +1,35 @@
+import { globSync } from 'glob';
+import path from 'node:path';
+import { RepoConfig } from './RepoConfig';
+export class MonorepoConfig extends RepoConfig {
+    constructor(env) {
+        super(env);
+        this.rootPackagesFolderPattern = env.rootPackagesFolderPattern;
+        this.ignoredPackagesFolderFiles = env.ignoredPackagesFolderFiles || [];
+        this.packages = env.packages || {};
+    }
+    getFolderOptions(folderPath) {
+        var _a, _b;
+        const options = super.getFolderOptions(folderPath);
+        const folder = path.basename(folderPath);
+        const folderIgnores = this.packages[folder];
+        if (!folderIgnores) {
+            return options;
+        }
+        if ((_a = folderIgnores.ignorePatterns) === null || _a === void 0 ? void 0 : _a.length) {
+            options.ignorePatterns = [...(options.ignorePatterns || []), ...folderIgnores.ignorePatterns];
+        }
+        if ((_b = folderIgnores.ignoreMatches) === null || _b === void 0 ? void 0 : _b.length) {
+            options.ignoreMatches = [...(options.ignoreMatches || []), ...folderIgnores.ignoreMatches];
+        }
+        return options;
+    }
+    getFolders() {
+        if (!this.folders) {
+            this.folders = globSync(this.rootPackagesFolderPattern, {
+                ignore: this.ignoredPackagesFolderFiles,
+            });
+        }
+        return this.folders;
+    }
+}

package/dist/esm/Config/RepoConfig.d.ts

@@ -0,0 +1,10 @@
+import { Options } from 'depcheck';
+import { RepoEnvType } from '../types';
+export declare class RepoConfig {
+    protected pwd: string;
+    private ignorePatterns?;
+    private ignoreMatches?;
+    constructor(env: RepoEnvType);
+    getFolders(): string[];
+    getFolderOptions(_folder: string): Options;
+}

package/dist/esm/Config/RepoConfig.js

@@ -0,0 +1,20 @@
+import path from 'node:path';
+export class RepoConfig {
+    constructor(env) {
+        this.pwd = path.resolve(env.cwd);
+        this.ignoreMatches = env.ignoreMatches || [];
+        this.ignorePatterns = env.ignorePatterns || [];
+    }
+    getFolders() {
+        return [this.pwd];
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getFolderOptions(_folder) {
+        return {
+            ignoreBinPackage: false,
+            skipMissing: false,
+            ignorePatterns: this.ignorePatterns,
+            ignoreMatches: this.ignoreMatches,
+        };
+    }
+}

package/dist/esm/Config/__tests__/MonorepoConfig.spec.d.ts

@@ -0,0 +1 @@
+export {};