@breadstone-tools/localizator-core 0.0.30 → 0.0.32

package/_tests/KeyConsistencyTask.Test.js

@@ -0,0 +1,160 @@
+"use strict";
+// // #region Imports
+// import { describe, it, expect } from 'vitest';
+// import { KeyConsistencyTask } from '../src/Resources/Analyzers/Tasks/KeyConsistencyTask';
+// import { JsonResourceInfo } from '../src/Resources/Models/JsonResourceInfo';
+// import type { IAnalyzerTaskExecutionContext, IAnalyzerTaskResult } from '../src/Resources/Analyzers/Tasks/Interfaces/IAnalyzerTask';
+// // #endregion
+// describe('KeyConsistencyTask', () => {
+//     it('should detect missing keys across locales', () => {
+//         const task = new KeyConsistencyTask(console);
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [
+//                 new JsonResourceInfo({
+//                     locale: 'en',
+//                     data: {
+//                         key1: 'value1',
+//                         key2: 'value2'
+//                     }
+//                 }),
+//                 new JsonResourceInfo({
+//                     locale: 'de',
+//                     data: {
+//                         key1: 'wert1'
+//                     }
+//                 })
+//             ],
+//             parameters: {}
+//         };
+//         const result: IAnalyzerTaskResult<any> = task.execute(context);
+//         expect(result.success).toBe(false);
+//         expect(result.data).toEqual([
+//             {
+//                 locale: 'en',
+//                 missingKeys: [],
+//                 isEmpty: false
+//             },
+//             {
+//                 locale: 'de',
+//                 missingKeys: ['key2'],
+//                 isEmpty: false
+//             }
+//         ]);
+//         expect(result.message).toBe('Inconsistencies found in locales.');
+//     });
+//     it('should detect empty locales', () => {
+//         const task = new KeyConsistencyTask(console);
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [
+//                 new JsonResourceInfo({
+//                     locale: 'en',
+//                     data: {}
+//                 }),
+//                 new JsonResourceInfo({
+//                     locale: 'de',
+//                     data: {
+//                         key1: 'wert1'
+//                     }
+//                 })
+//             ],
+//             parameters: {}
+//         };
+//         const result: IAnalyzerTaskResult<any> = task.execute(context);
+//         expect(result.success).toBe(false);
+//         expect(result.data).toEqual([
+//             {
+//                 locale: 'en',
+//                 missingKeys: [],
+//                 isEmpty: true
+//             },
+//             {
+//                 locale: 'de',
+//                 missingKeys: [],
+//                 isEmpty: false
+//             }
+//         ]);
+//         expect(result.message).toBe('Inconsistencies found in locales.');
+//     });
+//     it('should detect consistent keys across locales', () => {
+//         const task = new KeyConsistencyTask(console);
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [
+//                 new JsonResourceInfo({
+//                     locale: 'en',
+//                     data: {
+//                         key1: 'value1',
+//                         key2: 'value2'
+//                     }
+//                 }),
+//                 new JsonResourceInfo({
+//                     locale: 'de',
+//                     data: {
+//                         key1: 'wert1',
+//                         key2: 'wert2'
+//                     }
+//                 })
+//             ],
+//             parameters: {}
+//         };
+//         const result: IAnalyzerTaskResult<any> = task.execute(context);
+//         expect(result.success).toBe(true);
+//         expect(result.data).toEqual([
+//             {
+//                 locale: 'en',
+//                 missingKeys: [],
+//                 isEmpty: false
+//             },
+//             {
+//                 locale: 'de',
+//                 missingKeys: [],
+//                 isEmpty: false
+//             }
+//         ]);
+//         expect(result.message).toBe('All locales are consistent.');
+//     });
+//     it('should handle multiple missing keys across multiple locales', () => {
+//         const task = new KeyConsistencyTask(console);
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [
+//                 new JsonResourceInfo({
+//                     locale: 'en',
+//                     data: {
+//                         key1: 'value1'
+//                     }
+//                 }),
+//                 new JsonResourceInfo({
+//                     locale: 'de',
+//                     data: {
+//                         key2: 'wert2'
+//                     }
+//                 }),
+//                 new JsonResourceInfo({
+//                     locale: 'fr',
+//                     data: {}
+//                 })
+//             ],
+//             parameters: {}
+//         };
+//         const result: IAnalyzerTaskResult<any> = task.execute(context);
+//         expect(result.success).toBe(false);
+//         expect(result.data).toEqual([
+//             {
+//                 locale: 'fr',
+//                 missingKeys: [],
+//                 isEmpty: true
+//             },
+//             {
+//                 locale: 'en',
+//                 missingKeys: ['key2'],
+//                 isEmpty: false
+//             },
+//             {
+//                 locale: 'de',
+//                 missingKeys: ['key1'],
+//                 isEmpty: false
+//             }
+//         ]);
+//         expect(result.message).toBe('Inconsistencies found in locales.');
+//     });
+// });
+//# sourceMappingURL=KeyConsistencyTask.Test.js.map

package/_tests/KeyConsistencyTask.Test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyConsistencyTask.Test.js","sourceRoot":"","sources":["../../src/_tests/KeyConsistencyTask.Test.ts"],"names":[],"mappings":"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"}

package/_tests/KeyGenerator.Test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=KeyGenerator.Test.d.ts.map

package/_tests/KeyGenerator.Test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyGenerator.Test.d.ts","sourceRoot":"","sources":["../../src/_tests/KeyGenerator.Test.ts"],"names":[],"mappings":""}

package/_tests/KeyGenerator.Test.js

@@ -0,0 +1,70 @@
+"use strict";
+// import { describe, it, expect } from 'vitest';
+// import { KeyGenerator } from '../src/Services/KeyGenerator';
+// describe('KeyGenerator', () => {
+//     it('should generate a key for a simple string', () => {
+//         // Arrange
+//         const input = 'Facts Title';
+//         // Act
+//         const key = new KeyGenerator().generate(input);
+//         // Assert
+//         expect(key).toBe('facts.title');
+//     });
+//     it('should handle strings with special characters', () => {
+//         // Arrange
+//         const input = 'About (Description)';
+//         // Act
+//         const key = new KeyGenerator().generate(input);
+//         // Assert
+//         expect(key).toBe('about.description');
+//     });
+//     it('should handle strings with numbers', () => {
+//         // Arrange
+//         const input = 'Version 2.0';
+//         // Act
+//         const key = new KeyGenerator().generate(input);
+//         // Assert
+//         expect(key).toBe('version.2.0');
+//     });
+//     it('should ignore emojis in the input string', () => {
+//         // Arrange
+//         const input = 'Color copied to clipboard 🎉';
+//         // Act
+//         const key = new KeyGenerator().generate(input);
+//         // Assert
+//         expect(key).toBe('color.copied.to.clipboard');
+//     });
+//     it('should remove multiple spaces and trim the result', () => {
+//         // Arrange
+//         const input = '   Leading and    trailing spaces   ';
+//         // Act
+//         const key = new KeyGenerator().generate(input);
+//         // Assert
+//         expect(key).toBe('leading.and.trailing.spaces');
+//     });
+//     it('should handle empty strings', () => {
+//         // Arrange
+//         const input = '';
+//         // Act
+//         const key = new KeyGenerator().generate(input);
+//         // Assert
+//         expect(key).toBe('');
+//     });
+//     it('should handle strings with only emojis', () => {
+//         // Arrange
+//         const input = '🎉🚀👍';
+//         // Act
+//         const key = new KeyGenerator().generate(input);
+//         // Assert
+//         expect(key).toBe('');
+//     });
+//     it('should handle mixed content with emojis', () => {
+//         // Arrange
+//         const input = 'About the Team 👨‍👩‍👧‍👦';
+//         // Act
+//         const key = new KeyGenerator().generate(input);
+//         // Assert
+//         expect(key).toBe('about.the.team');
+//     });
+// });
+//# sourceMappingURL=KeyGenerator.Test.js.map

package/_tests/KeyGenerator.Test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyGenerator.Test.js","sourceRoot":"","sources":["../../src/_tests/KeyGenerator.Test.ts"],"names":[],"mappings":";AAAA,iDAAiD;AACjD,+DAA+D;AAE/D,mCAAmC;AACnC,8DAA8D;AAC9D,qBAAqB;AACrB,uCAAuC;AAEvC,iBAAiB;AACjB,0DAA0D;AAE1D,oBAAoB;AACpB,2CAA2C;AAC3C,UAAU;AAEV,kEAAkE;AAClE,qBAAqB;AACrB,+CAA+C;AAE/C,iBAAiB;AACjB,0DAA0D;AAE1D,oBAAoB;AACpB,iDAAiD;AACjD,UAAU;AAEV,uDAAuD;AACvD,qBAAqB;AACrB,uCAAuC;AAEvC,iBAAiB;AACjB,0DAA0D;AAE1D,oBAAoB;AACpB,2CAA2C;AAC3C,UAAU;AAEV,6DAA6D;AAC7D,qBAAqB;AACrB,wDAAwD;AAExD,iBAAiB;AACjB,0DAA0D;AAE1D,oBAAoB;AACpB,yDAAyD;AACzD,UAAU;AAEV,sEAAsE;AACtE,qBAAqB;AACrB,gEAAgE;AAEhE,iBAAiB;AACjB,0DAA0D;AAE1D,oBAAoB;AACpB,2DAA2D;AAC3D,UAAU;AAEV,gDAAgD;AAChD,qBAAqB;AACrB,4BAA4B;AAE5B,iBAAiB;AACjB,0DAA0D;AAE1D,oBAAoB;AACpB,gCAAgC;AAChC,UAAU;AAEV,2DAA2D;AAC3D,qBAAqB;AACrB,kCAAkC;AAElC,iBAAiB;AACjB,0DAA0D;AAE1D,oBAAoB;AACpB,gCAAgC;AAChC,UAAU;AAEV,4DAA4D;AAC5D,qBAAqB;AACrB,sDAAsD;AAEtD,iBAAiB;AACjB,0DAA0D;AAE1D,oBAAoB;AACpB,8CAA8C;AAC9C,UAAU;AACV,MAAM"}

package/_tests/LitPreset.Test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=LitPreset.Test.d.ts.map

package/_tests/LitPreset.Test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LitPreset.Test.d.ts","sourceRoot":"","sources":["../../src/_tests/LitPreset.Test.ts"],"names":[],"mappings":""}

package/_tests/LitPreset.Test.js

@@ -0,0 +1,16 @@
+"use strict";
+// import { describe, it, expect } from 'vitest';
+// import { LitPreset } from '../src/Presets/LitPreset.js';
+// import { TypeScriptParser } from '../src/Parsers/TypeScriptParser.js';
+// describe('LitPreset', () => {
+//     it('should create an instance', () => {
+//         const preset = new LitPreset(console);
+//         expect(preset).toBeTruthy();
+//     });
+//     it('should return correct parsers for file extensions', () => {
+//         const preset = new LitPreset(console);
+//         const parsers = preset.getParsers();
+//         expect(parsers['.ts']).toBeInstanceOf(TypeScriptParser);
+//     });
+// });
+//# sourceMappingURL=LitPreset.Test.js.map

package/_tests/LitPreset.Test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LitPreset.Test.js","sourceRoot":"","sources":["../../src/_tests/LitPreset.Test.ts"],"names":[],"mappings":";AAAA,iDAAiD;AACjD,2DAA2D;AAC3D,yEAAyE;AAEzE,gCAAgC;AAChC,8CAA8C;AAC9C,iDAAiD;AACjD,uCAAuC;AACvC,UAAU;AAEV,sEAAsE;AACtE,iDAAiD;AACjD,+CAA+C;AAE/C,mEAAmE;AACnE,UAAU;AACV,MAAM"}

package/_tests/LocalizationProcessor.Test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=LocalizationProcessor.Test.d.ts.map

package/_tests/LocalizationProcessor.Test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalizationProcessor.Test.d.ts","sourceRoot":"","sources":["../../src/_tests/LocalizationProcessor.Test.ts"],"names":[],"mappings":""}

package/_tests/LocalizationProcessor.Test.js

@@ -0,0 +1,121 @@
+"use strict";
+// // #region Imports
+// import { describe, it, expect, vi, beforeEach } from 'vitest';
+// import { LocalizationProcessor } from '../src/Services/LocalizationProcessor';
+// import type { IFileSystem } from '../src/IO/Interfaces/IFileSystem.js';
+// import { FileSystem } from '../src/IO/FileSystem.js';
+// import { FileCache } from '../src/IO/FileCache.js';
+// import { Presets } from '../src/Presets/Presets.js';
+// import type { IFormatter } from '../src/Formatters/Interfaces/IFormatter.js';
+// import type { IFrameworkPreset } from '../src/Presets/Interfaces/IFrameworkPreset.js';
+// import { EventEmitter } from 'events';
+// import type { IParserResult } from '../src/Parsers/Interfaces/IParser.js';
+// import { Formatters } from '../src/Formatters/Formatters.js';
+// // #endregion
+// describe('LocalizationProcessor', () => {
+//     let fileSystemMock: IFileSystem;
+//     let formatterMock: IFormatter;
+//     let presetMock: IFrameworkPreset;
+//     let localizationProcessor: LocalizationProcessor;
+//     beforeEach(() => {
+//         fileSystemMock = {
+//             glob: vi.fn(),
+//             readAllText: vi.fn()
+//         } as unknown as IFileSystem;
+//         formatterMock = {
+//             format: vi.fn((keyValueMap) => ({
+//                 content: JSON.stringify(keyValueMap),
+//                 changes: keyValueMap
+//             }))
+//         } as unknown as IFormatter;
+//         presetMock = {
+//             getParsers: vi.fn(),
+//             getParser: vi.fn(),
+//             getExtensions: vi.fn()
+//         } as unknown as IFrameworkPreset;
+//         localizationProcessor = new LocalizationProcessor(formatterMock, fileSystemMock);
+//     });
+//     it('should return an empty array if the root directory is empty', () => {
+//         // Arrange
+//         const rootDir = '';
+//         // Act
+//         const result = localizationProcessor.process(rootDir, presetMock);
+//         // Assert
+//         expect(result).toEqual([]);
+//     });
+//     it('should process files and return localization results', () => {
+//         // Arrange
+//         const parsers = { js: new EventEmitter() };
+//         const parserResult: IParserResult = {
+//             columnNumber: 0,
+//             lineNumber: 0,
+//             context: '',
+//             match: {
+//                 value: 'Hello, World!'
+//             }
+//         };
+//         presetMock.getParsers = vi.fn(() => parsers);
+//         presetMock.getParser = vi.fn(() => ({
+//             parse: vi.fn(() => [parserResult])
+//         }));
+//         presetMock.getExtensions = vi.fn(() => ['.js']);
+//         fileSystemMock.glob = vi.fn(() => ['/path/to/file.js']);
+//         fileSystemMock.readAllText = vi.fn(() => 'const message = "Hello, World!";');
+//         // Act
+//         const result = localizationProcessor.process('/root', presetMock);
+//         // Assert
+//         expect(fileSystemMock.glob).toHaveBeenCalledWith(['/root/**/*.js']);
+//         expect(fileSystemMock.readAllText).toHaveBeenCalledWith('/path/to/file.js');
+//         expect(presetMock.getParser).toHaveBeenCalledWith('.js');
+//         expect(result).toHaveLength(1);
+//         expect(result[0]).toEqual({
+//             filePath: '/path/to/file.js',
+//             parsings: [parserResult],
+//             extraction: {
+//                 content: '{"hello.world":"Hello, World!"}',
+//                 changes: { 'hello.world': 'Hello, World!' }
+//             }
+//         });
+//     });
+//     it('should emit "processed" events for each parser result', () => {
+//         // Arrange
+//         const parsers = { js: new EventEmitter() };
+//         const parserResult: IParserResult = { match: { value: 'Test String' } };
+//         const spyProcessed = vi.fn();
+//         localizationProcessor.on('processed', spyProcessed);
+//         presetMock.getParsers = vi.fn(() => parsers);
+//         presetMock.getParser = vi.fn(() => ({
+//             parse: vi.fn(() => [parserResult])
+//         }));
+//         presetMock.getExtensions = vi.fn(() => ['.js']);
+//         fileSystemMock.glob = vi.fn(() => ['/path/to/file.js']);
+//         fileSystemMock.readAllText = vi.fn(() => 'const message = "Test String";');
+//         // Act
+//         localizationProcessor.process('/root', presetMock);
+//         parsers.js.emit('parsed', parserResult);
+//         // Assert
+//         expect(spyProcessed).toHaveBeenCalledWith(parserResult);
+//     });
+//     it('should emit "failed" events on parser errors', () => {
+//         // Arrange
+//         const parsers = { js: new EventEmitter() };
+//         const error = new Error('Parser error');
+//         const spyFailed = vi.fn();
+//         localizationProcessor.on('failed', spyFailed);
+//         presetMock.getParsers = vi.fn(() => parsers);
+//         // Act
+//         localizationProcessor.process('/root', presetMock);
+//         parsers.js.emit('failed', error);
+//         // Assert
+//         expect(spyFailed).toHaveBeenCalledWith(error);
+//     });
+//     it('real world test', () => {
+//         const formatter = Formatters.get(Formatters.Json);
+//         const fileSystem = new FileSystem(new FileCache({ folder: './cache' }));
+//         const processor = new LocalizationProcessor(formatter, fileSystem);
+//         const preset = Presets.get(console, Presets.Angular);
+//         const result = processor.process(__dirname, preset);
+//         expect(result).toEqual([]);
+//     });
+// });
+//# sourceMappingURL=LocalizationProcessor.Test.js.map

package/_tests/LocalizationProcessor.Test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalizationProcessor.Test.js","sourceRoot":"","sources":["../../src/_tests/LocalizationProcessor.Test.ts"],"names":[],"mappings":";AAAA,qBAAqB;AAErB,iEAAiE;AACjE,iFAAiF;AACjF,0EAA0E;AAC1E,wDAAwD;AACxD,sDAAsD;AACtD,uDAAuD;AACvD,gFAAgF;AAChF,yFAAyF;AACzF,yCAAyC;AACzC,6EAA6E;AAC7E,gEAAgE;AAEhE,gBAAgB;AAEhB,4CAA4C;AAC5C,uCAAuC;AACvC,qCAAqC;AACrC,wCAAwC;AACxC,wDAAwD;AAExD,yBAAyB;AACzB,6BAA6B;AAC7B,6BAA6B;AAC7B,mCAAmC;AACnC,uCAAuC;AAEvC,4BAA4B;AAC5B,gDAAgD;AAChD,wDAAwD;AACxD,uCAAuC;AACvC,kBAAkB;AAClB,sCAAsC;AAEtC,yBAAyB;AACzB,mCAAmC;AACnC,kCAAkC;AAClC,qCAAqC;AACrC,4CAA4C;AAE5C,4FAA4F;AAC5F,UAAU;AAEV,gFAAgF;AAChF,qBAAqB;AACrB,8BAA8B;AAE9B,iBAAiB;AACjB,6EAA6E;AAE7E,oBAAoB;AACpB,sCAAsC;AACtC,UAAU;AAEV,yEAAyE;AACzE,qBAAqB;AACrB,sDAAsD;AACtD,gDAAgD;AAChD,+BAA+B;AAC/B,6BAA6B;AAC7B,2BAA2B;AAC3B,uBAAuB;AACvB,yCAAyC;AACzC,gBAAgB;AAChB,aAAa;AAEb,wDAAwD;AACxD,gDAAgD;AAChD,iDAAiD;AACjD,eAAe;AACf,2DAA2D;AAE3D,mEAAmE;AACnE,wFAAwF;AAExF,iBAAiB;AACjB,6EAA6E;AAE7E,oBAAoB;AACpB,+EAA+E;AAC/E,uFAAuF;AACvF,oEAAoE;AACpE,0CAA0C;AAC1C,sCAAsC;AACtC,4CAA4C;AAC5C,wCAAwC;AACxC,4BAA4B;AAC5B,8DAA8D;AAC9D,8DAA8D;AAC9D,gBAAgB;AAChB,cAAc;AACd,UAAU;AAEV,0EAA0E;AAC1E,qBAAqB;AACrB,sDAAsD;AACtD,mFAAmF;AACnF,wCAAwC;AAExC,+DAA+D;AAE/D,wDAAwD;AACxD,gDAAgD;AAChD,iDAAiD;AACjD,eAAe;AACf,2DAA2D;AAE3D,mEAAmE;AACnE,sFAAsF;AAEtF,iBAAiB;AACjB,8DAA8D;AAC9D,mDAAmD;AAEnD,oBAAoB;AACpB,mEAAmE;AACnE,UAAU;AAEV,iEAAiE;AACjE,qBAAqB;AACrB,sDAAsD;AACtD,mDAAmD;AACnD,qCAAqC;AAErC,yDAAyD;AACzD,wDAAwD;AAExD,iBAAiB;AACjB,8DAA8D;AAC9D,4CAA4C;AAE5C,oBAAoB;AACpB,yDAAyD;AACzD,UAAU;AAEV,oCAAoC;AACpC,6DAA6D;AAC7D,mFAAmF;AACnF,8EAA8E;AAC9E,gEAAgE;AAChE,+DAA+D;AAE/D,sCAAsC;AACtC,UAAU;AACV,MAAM"}

package/_tests/MissingTranslationsTask.Test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=MissingTranslationsTask.Test.d.ts.map

package/_tests/MissingTranslationsTask.Test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MissingTranslationsTask.Test.d.ts","sourceRoot":"","sources":["../../src/_tests/MissingTranslationsTask.Test.ts"],"names":[],"mappings":""}

package/_tests/MissingTranslationsTask.Test.js

@@ -0,0 +1,132 @@
+"use strict";
+// // #region Imports
+// import { describe, it, expect } from 'vitest';
+// import { MissingTranslationsTask } from '../src/Resources/Analyzers/Tasks/MissingTranslationsTask';
+// import type { IAnalyzerTaskExecutionContext } from '../src/Resources/Analyzers/Tasks/Interfaces/IAnalyzerTask';
+// import { JsonResourceInfo } from '../src/Resources/Models/JsonResourceInfo';
+// // #endregion
+// describe('MissingTranslationsTask', () => {
+//     it('should identify missing translations for resources with incomplete keys', () => {
+//         const task = new MissingTranslationsTask(console);
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [
+//                 new JsonResourceInfo({
+//                     locale: 'en',
+//                     data: {
+//                         key1: 'value1',
+//                         key2: 'value2'
+//                     }
+//                 }),
+//                 new JsonResourceInfo({
+//                     locale: 'de',
+//                     data: {
+//                         key1: 'wert1'
+//                         // Missing key2
+//                     }
+//                 })
+//             ],
+//             parameters: {}
+//         };
+//         const result = task.execute(context);
+//         expect(result.success).toBe(false);
+//         expect(result.message).toBe('Some resources are missing translations.');
+//         expect(result.data).toEqual([
+//             {
+//                 locale: 'de',
+//                 missingKeys: ['key2']
+//             }
+//         ]);
+//     });
+//     it('should return success for resources with all required translations', () => {
+//         const task = new MissingTranslationsTask(console);
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [
+//                 new JsonResourceInfo({
+//                     locale: 'en',
+//                     data: {
+//                         key1: 'value1',
+//                         key2: 'value2'
+//                     }
+//                 }),
+//                 new JsonResourceInfo({
+//                     locale: 'de',
+//                     data: {
+//                         key1: 'wert1',
+//                         key2: 'wert2'
+//                     }
+//                 })
+//             ],
+//             parameters: {}
+//         };
+//         const result = task.execute(context);
+//         expect(result.success).toBe(true);
+//         expect(result.message).toBe('All resources have complete translations.');
+//         expect(result.data).toEqual([]);
+//     });
+//     it('should handle resources with no keys', () => {
+//         const task = new MissingTranslationsTask(console);
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [
+//                 new JsonResourceInfo({
+//                     locale: 'en',
+//                     data: {}
+//                 }),
+//                 new JsonResourceInfo({
+//                     locale: 'de',
+//                     data: {}
+//                 })
+//             ],
+//             parameters: {}
+//         };
+//         const result = task.execute(context);
+//         expect(result.success).toBe(true);
+//         expect(result.message).toBe('All resources have complete translations.');
+//         expect(result.data).toEqual([]);
+//     });
+//     it('should handle a single resource with missing translations', () => {
+//         const task = new MissingTranslationsTask(console);
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [
+//                 new JsonResourceInfo({
+//                     locale: 'en',
+//                     data: {
+//                         key1: 'value1',
+//                         key2: 'value2'
+//                     }
+//                 })
+//             ],
+//             parameters: {}
+//         };
+//         const result = task.execute(context);
+//         expect(result.success).toBe(true);
+//         expect(result.message).toBe('All resources have complete translations.');
+//         expect(result.data).toEqual([]);
+//     });
+//     it('should handle resources with duplicate missing keys correctly', () => {
+//         const task = new MissingTranslationsTask(console);
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [
+//                 new JsonResourceInfo({
+//                     locale: 'en',
+//                     data: {
+//                         key1: 'value1'
+//                         // Missing key2
+//                     }
+//                 }),
+//                 new JsonResourceInfo({
+//                     locale: 'de',
+//                     data: {
+//                         key1: 'wert1'
+//                         // Missing key2
+//                     }
+//                 })
+//             ],
+//             parameters: {}
+//         };
+//         const result = task.execute(context);
+//         expect(result.success).toBe(true);
+//         expect(result.message).toBe('All resources have complete translations.');
+//         expect(result.data).toEqual([]);
+//     });
+// });
+//# sourceMappingURL=MissingTranslationsTask.Test.js.map

package/_tests/MissingTranslationsTask.Test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MissingTranslationsTask.Test.js","sourceRoot":"","sources":["../../src/_tests/MissingTranslationsTask.Test.ts"],"names":[],"mappings":";AAAA,qBAAqB;AAErB,iDAAiD;AACjD,sGAAsG;AACtG,kHAAkH;AAClH,+EAA+E;AAE/E,gBAAgB;AAEhB,8CAA8C;AAC9C,4FAA4F;AAC5F,6DAA6D;AAC7D,2DAA2D;AAC3D,2BAA2B;AAC3B,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,0CAA0C;AAC1C,yCAAyC;AACzC,wBAAwB;AACxB,sBAAsB;AACtB,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,wCAAwC;AACxC,0CAA0C;AAC1C,wBAAwB;AACxB,qBAAqB;AACrB,iBAAiB;AACjB,6BAA6B;AAC7B,aAAa;AAEb,gDAAgD;AAEhD,8CAA8C;AAC9C,mFAAmF;AACnF,wCAAwC;AACxC,gBAAgB;AAChB,gCAAgC;AAChC,wCAAwC;AACxC,gBAAgB;AAChB,cAAc;AACd,UAAU;AAEV,uFAAuF;AACvF,6DAA6D;AAC7D,2DAA2D;AAC3D,2BAA2B;AAC3B,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,0CAA0C;AAC1C,yCAAyC;AACzC,wBAAwB;AACxB,sBAAsB;AACtB,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,yCAAyC;AACzC,wCAAwC;AACxC,wBAAwB;AACxB,qBAAqB;AACrB,iBAAiB;AACjB,6BAA6B;AAC7B,aAAa;AAEb,gDAAgD;AAEhD,6CAA6C;AAC7C,oFAAoF;AACpF,2CAA2C;AAC3C,UAAU;AAEV,yDAAyD;AACzD,6DAA6D;AAC7D,2DAA2D;AAC3D,2BAA2B;AAC3B,yCAAyC;AACzC,oCAAoC;AACpC,+BAA+B;AAC/B,sBAAsB;AACtB,yCAAyC;AACzC,oCAAoC;AACpC,+BAA+B;AAC/B,qBAAqB;AACrB,iBAAiB;AACjB,6BAA6B;AAC7B,aAAa;AAEb,gDAAgD;AAEhD,6CAA6C;AAC7C,oFAAoF;AACpF,2CAA2C;AAC3C,UAAU;AAEV,8EAA8E;AAC9E,6DAA6D;AAC7D,2DAA2D;AAC3D,2BAA2B;AAC3B,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,0CAA0C;AAC1C,yCAAyC;AACzC,wBAAwB;AACxB,qBAAqB;AACrB,iBAAiB;AACjB,6BAA6B;AAC7B,aAAa;AAEb,gDAAgD;AAEhD,6CAA6C;AAC7C,oFAAoF;AACpF,2CAA2C;AAC3C,UAAU;AAEV,kFAAkF;AAClF,6DAA6D;AAC7D,2DAA2D;AAC3D,2BAA2B;AAC3B,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,yCAAyC;AACzC,0CAA0C;AAC1C,wBAAwB;AACxB,sBAAsB;AACtB,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,wCAAwC;AACxC,0CAA0C;AAC1C,wBAAwB;AACxB,qBAAqB;AACrB,iBAAiB;AACjB,6BAA6B;AAC7B,aAAa;AAEb,gDAAgD;AAEhD,6CAA6C;AAC7C,oFAAoF;AACpF,2CAA2C;AAC3C,UAAU;AACV,MAAM"}

package/_tests/ReactPreset.Test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=ReactPreset.Test.d.ts.map

package/_tests/ReactPreset.Test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactPreset.Test.d.ts","sourceRoot":"","sources":["../../src/_tests/ReactPreset.Test.ts"],"names":[],"mappings":""}

package/_tests/ReactPreset.Test.js

@@ -0,0 +1,16 @@
+"use strict";
+// import { describe, it, expect } from 'vitest';
+// import { JavaScriptParser } from '../src/Parsers/JavaScriptParser.js';
+// import { JSXParser } from '../src/Parsers/JSXParser.js';
+// import { TypeScriptParser } from '../src/Parsers/TypeScriptParser.js';
+// import { ReactPreset } from '../src/Presets/ReactPreset.js';
+// describe('ReactPreset', () => {
+//     it('should return correct parsers for file extensions', () => {
+//         const preset = new ReactPreset(console);
+//         const parsers = preset.getParsers();
+//         expect(parsers['.jsx']).toBeInstanceOf(JSXParser);
+//         expect(parsers['.js']).toBeInstanceOf(JavaScriptParser);
+//         expect(parsers['.ts']).toBeInstanceOf(TypeScriptParser);
+//     });
+// });
+//# sourceMappingURL=ReactPreset.Test.js.map

package/_tests/ReactPreset.Test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactPreset.Test.js","sourceRoot":"","sources":["../../src/_tests/ReactPreset.Test.ts"],"names":[],"mappings":";AAAA,iDAAiD;AACjD,yEAAyE;AACzE,2DAA2D;AAC3D,yEAAyE;AACzE,+DAA+D;AAE/D,kCAAkC;AAClC,sEAAsE;AACtE,mDAAmD;AACnD,+CAA+C;AAE/C,6DAA6D;AAC7D,mEAAmE;AACnE,mEAAmE;AACnE,UAAU;AACV,MAAM"}

package/_tests/ResourceProcessor.Test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=ResourceProcessor.Test.d.ts.map

package/_tests/ResourceProcessor.Test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceProcessor.Test.d.ts","sourceRoot":"","sources":["../../src/_tests/ResourceProcessor.Test.ts"],"names":[],"mappings":""}

package/_tests/ResourceProcessor.Test.js

@@ -0,0 +1,31 @@
+"use strict";
+// // #region Imports
+// import { describe, it, expect } from 'vitest';
+// import { ResourceProcessor } from '../src/Resources/ResourceProcessor';
+// import { ResourceScanner } from '../src/Resources/Scanners/ResourceScanner';
+// import { ResourceTransformer } from '../src/Resources/Transformers/ResourceTransformer';
+// import { FileSystem } from '../src/IO/FileSystem';
+// import { FileCache } from '../src/IO/FileCache';
+// import { ResourceMode } from '../src/Resources/ResourceMode';
+// import { ResourceAnalyzer } from '../src/Resources/Analyzers/ResourceAnalyzer';
+// import { ResourceSorter } from '../src/Resources/Sorting/ResourceSorter';
+// // #endregion
+// describe('ResourceProcessor', () => {
+//     it('should log a warning for empty locales', () => {
+//         const fc = new FileCache({
+//             disabeld: true,
+//             folder: './.cache'
+//         });
+//         const fs = new FileSystem(fc);
+//         const scanner = new ResourceScanner(console, fs, {
+//             cwd: './',
+//             mode: ResourceMode.Json
+//         });
+//         const transformer = new ResourceTransformer(console);
+//         const analyzer = new ResourceAnalyzer(console);
+//         const sorter = new ResourceSorter(console, { dryRun: false });
+//         const processor = new ResourceProcessor(console, scanner, transformer, analyzer, sorter);
+//         expect(processor).toBeDefined();
+//     });
+// });
+//# sourceMappingURL=ResourceProcessor.Test.js.map

package/_tests/ResourceProcessor.Test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceProcessor.Test.js","sourceRoot":"","sources":["../../src/_tests/ResourceProcessor.Test.ts"],"names":[],"mappings":";AAAA,qBAAqB;AAErB,iDAAiD;AACjD,0EAA0E;AAC1E,+EAA+E;AAC/E,2FAA2F;AAC3F,qDAAqD;AACrD,mDAAmD;AACnD,gEAAgE;AAChE,kFAAkF;AAClF,4EAA4E;AAE5E,gBAAgB;AAEhB,wCAAwC;AACxC,2DAA2D;AAC3D,qCAAqC;AACrC,8BAA8B;AAC9B,iCAAiC;AACjC,cAAc;AACd,yCAAyC;AACzC,6DAA6D;AAC7D,yBAAyB;AACzB,sCAAsC;AACtC,cAAc;AACd,gEAAgE;AAChE,0DAA0D;AAC1D,yEAAyE;AACzE,oGAAoG;AAEpG,2CAA2C;AAC3C,UAAU;AACV,MAAM"}

package/_tests/ResxFormatter.Test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=ResxFormatter.Test.d.ts.map

package/_tests/ResxFormatter.Test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResxFormatter.Test.d.ts","sourceRoot":"","sources":["../../src/_tests/ResxFormatter.Test.ts"],"names":[],"mappings":""}