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

package/src/Config/__tests__/MonorepoConfig.spec.ts

@@ -0,0 +1,346 @@
+import { globSync } from 'glob';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { MonorepoConfig } from '../MonorepoConfig';
+
+vi.mock('glob', () => ({
+  globSync: vi.fn(),
+}));
+
+describe('MonorepoConfig', () => {
+  const mockGlobSync = vi.mocked(globSync);
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with required fields', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      mockGlobSync.mockReturnValueOnce(['packages/package1']);
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+      });
+
+      expect(config.getFolders()).toBeDefined();
+    });
+
+    it('should use empty array as default for ignoredPackagesFolderFiles', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+      });
+
+      mockGlobSync.mockReturnValueOnce(['packages/package1']);
+      config.getFolders();
+
+      expect(mockGlobSync).toHaveBeenCalledWith(rootPackagesFolderPattern, {
+        ignore: [],
+      });
+    });
+
+    it('should initialize with packages', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const packages = {
+        package1: {
+          ignorePatterns: ['dist'],
+          ignoreMatches: ['@cloud-ru/test'],
+        },
+      };
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+        packages,
+      });
+
+      const options = config.getFolderOptions('/test/directory/packages/package1');
+
+      expect(options.ignorePatterns).toContain('dist');
+      expect(options.ignoreMatches).toContain('@cloud-ru/test');
+    });
+
+    it('should use empty object as default for packages', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+      });
+
+      const options = config.getFolderOptions('/test/directory/packages/package1');
+
+      expect(options).toEqual({
+        ignoreBinPackage: false,
+        skipMissing: false,
+        ignorePatterns: [],
+        ignoreMatches: [],
+      });
+    });
+
+    it('should call parent constructor with cwd', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+      });
+
+      mockGlobSync.mockReturnValueOnce(['packages/package1']);
+      const folders = config.getFolders();
+
+      expect(mockGlobSync).toHaveBeenCalled();
+      expect(folders).toEqual(['packages/package1']);
+    });
+  });
+
+  describe('getFolders', () => {
+    it('should return folders from globSync', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const mockFolders = ['packages/package1', 'packages/package2'];
+      mockGlobSync.mockReturnValueOnce(mockFolders);
+
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+      });
+
+      const folders = config.getFolders();
+
+      expect(folders).toEqual(mockFolders);
+      expect(mockGlobSync).toHaveBeenCalledWith(rootPackagesFolderPattern, {
+        ignore: [],
+      });
+    });
+
+    it('should use ignoredPackagesFolderFiles in globSync', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const ignoredPackagesFolderFiles = ['file1.json'];
+      const mockFolders = ['packages/package1'];
+      mockGlobSync.mockReturnValueOnce(mockFolders);
+
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+        ignoredPackagesFolderFiles,
+      });
+
+      const folders = config.getFolders();
+
+      expect(folders).toEqual(mockFolders);
+      expect(mockGlobSync).toHaveBeenCalledWith(rootPackagesFolderPattern, {
+        ignore: ignoredPackagesFolderFiles,
+      });
+    });
+
+    it('should cache folders result', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const mockFolders = ['packages/package1'];
+      mockGlobSync.mockReturnValueOnce(mockFolders);
+
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+      });
+
+      const folders1 = config.getFolders();
+      const folders2 = config.getFolders();
+
+      expect(folders1).toEqual(mockFolders);
+      expect(folders2).toEqual(mockFolders);
+      expect(mockGlobSync).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('getFolderOptions', () => {
+    it('should return Options object with correct structure', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+      });
+
+      const options = config.getFolderOptions('/test/directory/packages/package1');
+
+      expect(options).toHaveProperty('ignoreBinPackage');
+      expect(options).toHaveProperty('skipMissing');
+      expect(options).toHaveProperty('ignorePatterns');
+      expect(options).toHaveProperty('ignoreMatches');
+    });
+
+    it('should merge ignorePatterns from parent and package config', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const parentIgnorePatterns = ['dist', 'node_modules'];
+      const packageIgnorePatterns = ['build', 'coverage'];
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+        ignorePatterns: parentIgnorePatterns,
+        packages: {
+          package1: {
+            ignorePatterns: packageIgnorePatterns,
+          },
+        },
+      });
+
+      const options = config.getFolderOptions('/test/directory/packages/package1');
+
+      expect(options.ignorePatterns).toEqual([...parentIgnorePatterns, ...packageIgnorePatterns]);
+    });
+
+    it('should merge ignoreMatches from parent and package config', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const parentIgnoreMatches = ['@cloud-ru/package1'];
+      const packageIgnoreMatches = ['@cloud-ru/package2'];
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+        ignoreMatches: parentIgnoreMatches,
+        packages: {
+          package1: {
+            ignoreMatches: packageIgnoreMatches,
+          },
+        },
+      });
+
+      const options = config.getFolderOptions('/test/directory/packages/package1');
+
+      expect(options.ignoreMatches).toEqual([...parentIgnoreMatches, ...packageIgnoreMatches]);
+    });
+
+    it('should merge both ignorePatterns and ignoreMatches from package config', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const parentIgnorePatterns = ['dist'];
+      const parentIgnoreMatches = ['@cloud-ru/package1'];
+      const packageIgnorePatterns = ['build'];
+      const packageIgnoreMatches = ['@cloud-ru/package2'];
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+        ignorePatterns: parentIgnorePatterns,
+        ignoreMatches: parentIgnoreMatches,
+        packages: {
+          package1: {
+            ignorePatterns: packageIgnorePatterns,
+            ignoreMatches: packageIgnoreMatches,
+          },
+        },
+      });
+
+      const options = config.getFolderOptions('/test/directory/packages/package1');
+
+      expect(options.ignorePatterns).toEqual([...parentIgnorePatterns, ...packageIgnorePatterns]);
+      expect(options.ignoreMatches).toEqual([...parentIgnoreMatches, ...packageIgnoreMatches]);
+    });
+
+    it('should use only parent options when package config is not provided', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const parentIgnorePatterns = ['dist'];
+      const parentIgnoreMatches = ['@cloud-ru/package1'];
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+        ignorePatterns: parentIgnorePatterns,
+        ignoreMatches: parentIgnoreMatches,
+      });
+
+      const options = config.getFolderOptions('/test/directory/packages/package1');
+
+      expect(options.ignorePatterns).toEqual(parentIgnorePatterns);
+      expect(options.ignoreMatches).toEqual(parentIgnoreMatches);
+    });
+
+    it('should use only parent options when package config does not have ignorePatterns', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const parentIgnorePatterns = ['dist'];
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+        ignorePatterns: parentIgnorePatterns,
+        packages: {
+          package1: {
+            ignoreMatches: ['@cloud-ru/package2'],
+          },
+        },
+      });
+
+      const options = config.getFolderOptions('/test/directory/packages/package1');
+
+      expect(options.ignorePatterns).toEqual(parentIgnorePatterns);
+    });
+
+    it('should use only parent options when package config does not have ignoreMatches', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const parentIgnoreMatches = ['@cloud-ru/package1'];
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+        ignoreMatches: parentIgnoreMatches,
+        packages: {
+          package1: {
+            ignorePatterns: ['build'],
+          },
+        },
+      });
+
+      const options = config.getFolderOptions('/test/directory/packages/package1');
+
+      expect(options.ignoreMatches).toEqual(parentIgnoreMatches);
+    });
+
+    it('should use folder name from path to get package config', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+        packages: {
+          package1: {
+            ignorePatterns: ['dist'],
+          },
+          package2: {
+            ignorePatterns: ['build'],
+          },
+        },
+      });
+
+      const options1 = config.getFolderOptions('/test/directory/packages/package1');
+      const options2 = config.getFolderOptions('/test/directory/packages/package2');
+
+      expect(options1.ignorePatterns).toContain('dist');
+      expect(options2.ignorePatterns).toContain('build');
+    });
+
+    it('should return parent options when package config is empty', () => {
+      const testCwd = '/test/directory';
+      const rootPackagesFolderPattern = 'packages/*';
+      const parentIgnorePatterns = ['dist'];
+      const config = new MonorepoConfig({
+        cwd: testCwd,
+        rootPackagesFolderPattern,
+        ignorePatterns: parentIgnorePatterns,
+        packages: {
+          package1: {},
+        },
+      });
+
+      const options = config.getFolderOptions('/test/directory/packages/package1');
+
+      expect(options.ignorePatterns).toEqual(parentIgnorePatterns);
+    });
+  });
+});

package/src/Config/__tests__/RepoConfig.spec.ts

@@ -0,0 +1,131 @@
+import path from 'path';
+
+import { describe, expect, it } from 'vitest';
+
+import { RepoConfig } from '../RepoConfig';
+
+describe('RepoConfig', () => {
+  describe('constructor', () => {
+    it('should initialize with cwd and resolve path', () => {
+      const testCwd = '/test/directory';
+      const config = new RepoConfig({ cwd: testCwd });
+
+      expect(config.getFolders()).toEqual([path.resolve(testCwd)]);
+    });
+
+    it('should initialize with ignorePatterns', () => {
+      const testCwd = '/test/directory';
+      const ignorePatterns = ['dist', 'node_modules'];
+      const config = new RepoConfig({ cwd: testCwd, ignorePatterns });
+
+      const options = config.getFolderOptions('any-folder');
+
+      expect(options.ignorePatterns).toEqual(ignorePatterns);
+    });
+
+    it('should initialize with ignoreMatches', () => {
+      const testCwd = '/test/directory';
+      const ignoreMatches = ['@cloud-ru/package1', '@cloud-ru/package2'];
+      const config = new RepoConfig({ cwd: testCwd, ignoreMatches });
+
+      const options = config.getFolderOptions('any-folder');
+
+      expect(options.ignoreMatches).toEqual(ignoreMatches);
+    });
+
+    it('should initialize with both ignorePatterns and ignoreMatches', () => {
+      const testCwd = '/test/directory';
+      const ignorePatterns = ['dist'];
+      const ignoreMatches = ['@cloud-ru/package'];
+      const config = new RepoConfig({ cwd: testCwd, ignorePatterns, ignoreMatches });
+
+      const options = config.getFolderOptions('any-folder');
+
+      expect(options.ignorePatterns).toEqual(ignorePatterns);
+      expect(options.ignoreMatches).toEqual(ignoreMatches);
+    });
+
+    it('should use empty arrays as default for optional fields', () => {
+      const testCwd = '/test/directory';
+      const config = new RepoConfig({ cwd: testCwd });
+
+      const options = config.getFolderOptions('any-folder');
+
+      expect(options.ignorePatterns).toEqual([]);
+      expect(options.ignoreMatches).toEqual([]);
+    });
+
+    it('should resolve relative cwd path to absolute', () => {
+      const relativePath = './test';
+      const config = new RepoConfig({ cwd: relativePath });
+
+      const folders = config.getFolders();
+
+      expect(folders[0]).toBe(path.resolve(relativePath));
+      expect(path.isAbsolute(folders[0])).toBe(true);
+    });
+  });
+
+  describe('getFolders', () => {
+    it('should return array with resolved pwd', () => {
+      const testCwd = '/test/directory';
+      const config = new RepoConfig({ cwd: testCwd });
+
+      const folders = config.getFolders();
+
+      expect(folders).toEqual([path.resolve(testCwd)]);
+    });
+
+    it('should always return absolute path', () => {
+      const relativeCwd = '../test';
+      const config = new RepoConfig({ cwd: relativeCwd });
+
+      const folders = config.getFolders();
+
+      expect(path.isAbsolute(folders[0])).toBe(true);
+    });
+  });
+
+  describe('getFolderOptions', () => {
+    it('should return Options object with correct structure', () => {
+      const testCwd = '/test/directory';
+      const config = new RepoConfig({ cwd: testCwd });
+      const folder = 'any-folder';
+
+      const options = config.getFolderOptions(folder);
+
+      expect(options).toHaveProperty('ignoreBinPackage');
+      expect(options).toHaveProperty('skipMissing');
+      expect(options).toHaveProperty('ignorePatterns');
+      expect(options).toHaveProperty('ignoreMatches');
+    });
+
+    it('should return ignoreBinPackage as false', () => {
+      const testCwd = '/test/directory';
+      const config = new RepoConfig({ cwd: testCwd });
+
+      const options = config.getFolderOptions('any-folder');
+
+      expect(options.ignoreBinPackage).toBe(false);
+    });
+
+    it('should return skipMissing as false', () => {
+      const testCwd = '/test/directory';
+      const config = new RepoConfig({ cwd: testCwd });
+
+      const options = config.getFolderOptions('any-folder');
+
+      expect(options.skipMissing).toBe(false);
+    });
+
+    it('should return empty arrays when optional fields are not provided', () => {
+      const testCwd = '/test/directory';
+      const config = new RepoConfig({ cwd: testCwd });
+
+      const options = config.getFolderOptions('any-folder');
+
+      expect(options.ignorePatterns).toEqual([]);
+      expect(options.ignoreMatches).toEqual([]);
+    });
+  });
+});

package/src/Config/index.ts

@@ -0,0 +1,2 @@
+export { RepoConfig } from './RepoConfig';
+export { MonorepoConfig } from './MonorepoConfig';

package/src/Report/__tests__/Report.spec.ts

@@ -0,0 +1,221 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { logError, logInfo } from '../../utils/console';
+import { Report } from '../index';
+
+vi.mock('../../utils/console', () => ({
+  logError: vi.fn(),
+  logInfo: vi.fn(),
+}));
+
+describe('Report', () => {
+  let report: Report;
+
+  beforeEach(() => {
+    report = new Report();
+    vi.clearAllMocks();
+  });
+
+  describe('add', () => {
+    it('should add state to storage', () => {
+      const folder = 'packages/test-package';
+      const state = {
+        dependencies: ['unused-dep'],
+        wrongVersions: ['@cloud-ru/package'],
+      };
+
+      report.add(folder, state);
+
+      const exitCode = report.printResultAndGetExitCode();
+      expect(exitCode).toBe(1);
+      expect(logInfo).toHaveBeenCalled();
+      expect(logError).toHaveBeenCalled();
+    });
+
+    it('should throw error when trying to add state for existing folder', () => {
+      const folder = 'packages/test-package';
+      const firstState = {
+        dependencies: ['unused-dep'],
+      };
+      const secondState = {
+        wrongVersions: ['@cloud-ru/package'],
+      };
+
+      report.add(folder, firstState);
+
+      expect(() => {
+        report.add(folder, secondState);
+      }).toThrow(`There is check state in storage already for: ${folder}`);
+    });
+  });
+
+  describe('printResultAndGetExitCode', () => {
+    it('should return 0 when storage is empty', () => {
+      const exitCode = report.printResultAndGetExitCode();
+
+      expect(exitCode).toBe(0);
+      expect(logInfo).not.toHaveBeenCalled();
+      expect(logError).not.toHaveBeenCalled();
+    });
+
+    it('should return 0 when there are no errors', () => {
+      report.add('packages/test-package', {
+        dependencies: [],
+        wrongVersions: [],
+        internalAsDev: [],
+        missing: {},
+      });
+
+      const exitCode = report.printResultAndGetExitCode();
+
+      expect(exitCode).toBe(0);
+      expect(logInfo).not.toHaveBeenCalled();
+      expect(logError).not.toHaveBeenCalled();
+    });
+
+    it('should return 1 and log errors when wrongVersions exist', () => {
+      const folder = 'packages/test-package';
+      const wrongVersions = ['@cloud-ru/package1', '@cloud-ru/package2'];
+
+      report.add(folder, {
+        wrongVersions,
+      });
+
+      const exitCode = report.printResultAndGetExitCode();
+
+      expect(exitCode).toBe(1);
+      expect(logInfo).toHaveBeenCalledWith(folder);
+      expect(logError).toHaveBeenCalledWith('\twrong version of internal packages:');
+      expect(logError).toHaveBeenCalledWith('\t\t@cloud-ru/package1');
+      expect(logError).toHaveBeenCalledWith('\t\t@cloud-ru/package2');
+    });
+
+    it('should return 1 and log errors when internalAsDev exist', () => {
+      const folder = 'packages/test-package';
+      const internalAsDev = ['@cloud-ru/package1', '@cloud-ru/package2'];
+
+      report.add(folder, {
+        internalAsDev,
+      });
+
+      const exitCode = report.printResultAndGetExitCode();
+
+      expect(exitCode).toBe(1);
+      expect(logInfo).toHaveBeenCalledWith(folder);
+      expect(logError).toHaveBeenCalledWith('\tincorrect usage as dev dep of internal packages:');
+      expect(logError).toHaveBeenCalledWith('\t\t@cloud-ru/package1');
+      expect(logError).toHaveBeenCalledWith('\t\t@cloud-ru/package2');
+    });
+
+    it('should return 1 and log errors when dependencies exist', () => {
+      const folder = 'packages/test-package';
+      const dependencies = ['unused-dep1', 'unused-dep2'];
+
+      report.add(folder, {
+        dependencies,
+      });
+
+      const exitCode = report.printResultAndGetExitCode();
+
+      expect(exitCode).toBe(1);
+      expect(logInfo).toHaveBeenCalledWith(folder);
+      expect(logError).toHaveBeenCalledWith('\tunused dependencies:');
+      expect(logError).toHaveBeenCalledWith('\t\tunused-dep1');
+      expect(logError).toHaveBeenCalledWith('\t\tunused-dep2');
+    });
+
+    it('should return 1 and log errors when missing dependencies exist', () => {
+      const folder = 'packages/test-package';
+      const missing = {
+        'missing-package1': ['file1.ts', 'file2.ts'],
+        'missing-package2': ['file3.ts'],
+      };
+
+      report.add(folder, {
+        missing,
+      });
+
+      const exitCode = report.printResultAndGetExitCode();
+
+      expect(exitCode).toBe(1);
+      expect(logInfo).toHaveBeenCalledWith(folder);
+      expect(logError).toHaveBeenCalledWith('\tmissing dependencies:');
+      expect(logError).toHaveBeenCalledWith('\t\tmissing-package1');
+      expect(logError).toHaveBeenCalledWith('\t\tfile1.ts');
+      expect(logError).toHaveBeenCalledWith('\t\tfile2.ts');
+      expect(logError).toHaveBeenCalledWith('\t\tmissing-package2');
+      expect(logError).toHaveBeenCalledWith('\t\tfile3.ts');
+    });
+
+    it('should handle all error types together', () => {
+      const folder = 'packages/test-package';
+
+      report.add(folder, {
+        wrongVersions: ['@cloud-ru/package1'],
+        internalAsDev: ['@cloud-ru/package2'],
+        dependencies: ['unused-dep'],
+        missing: {
+          'missing-package': ['file.ts'],
+        },
+      });
+
+      const exitCode = report.printResultAndGetExitCode();
+
+      expect(exitCode).toBe(1);
+      expect(logInfo).toHaveBeenCalledWith(folder);
+      expect(logError).toHaveBeenCalledWith('\twrong version of internal packages:');
+      expect(logError).toHaveBeenCalledWith('\t\t@cloud-ru/package1');
+      expect(logError).toHaveBeenCalledWith('\tincorrect usage as dev dep of internal packages:');
+      expect(logError).toHaveBeenCalledWith('\t\t@cloud-ru/package2');
+      expect(logError).toHaveBeenCalledWith('\tunused dependencies:');
+      expect(logError).toHaveBeenCalledWith('\t\tunused-dep');
+      expect(logError).toHaveBeenCalledWith('\tmissing dependencies:');
+      expect(logError).toHaveBeenCalledWith('\t\tmissing-package');
+      expect(logError).toHaveBeenCalledWith('\t\tfile.ts');
+    });
+
+    it('should process multiple packages', () => {
+      report.add('packages/package1', {
+        wrongVersions: ['@cloud-ru/package'],
+      });
+
+      report.add('packages/package2', {
+        dependencies: ['unused-dep'],
+      });
+
+      const exitCode = report.printResultAndGetExitCode();
+
+      expect(exitCode).toBe(1);
+      expect(logInfo).toHaveBeenCalledWith('packages/package1');
+      expect(logError).toHaveBeenCalledWith(expect.stringContaining('wrong version'));
+      expect(logInfo).toHaveBeenCalledWith('packages/package2');
+      expect(logError).toHaveBeenCalledWith(expect.stringContaining('unused dependencies'));
+    });
+
+    it('should use default values for undefined fields', () => {
+      const folder = 'packages/test-package';
+
+      report.add(folder, {});
+
+      const exitCode = report.printResultAndGetExitCode();
+
+      expect(exitCode).toBe(0);
+      expect(logInfo).not.toHaveBeenCalled();
+      expect(logError).not.toHaveBeenCalled();
+    });
+
+    it('should format messages with correct tabs', () => {
+      const folder = 'packages/test-package';
+
+      report.add(folder, {
+        wrongVersions: ['@cloud-ru/package'],
+      });
+
+      report.printResultAndGetExitCode();
+
+      expect(logInfo).toHaveBeenCalledWith('packages/test-package');
+      expect(logError).toHaveBeenCalledWith('\twrong version of internal packages:');
+      expect(logError).toHaveBeenCalledWith('\t\t@cloud-ru/package');
+    });
+  });
+});