@breadstone-tools/localizator-core 0.0.31 → 0.0.33

package/_tests/AngularHTMLParser.Test.d.ts

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

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

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

package/_tests/AngularHTMLParser.Test.js

@@ -0,0 +1,99 @@
+"use strict";
+// // #region Imports
+// import { AngularHTMLDetector } from '../src/Detectors/AngularHTMLDetector';
+// import { describe, it, expect } from 'vitest';
+// // #endregion
+// describe('AngularHTMLParser', () => {
+//     it('should extract strings from text interpolation', () => {
+//         const content = '<label>{{ \'This is a sentence\' | translate }}</label>';
+//         const parser = new AngularHTMLDetector(console);
+//         const result = parser.detect(content);
+//         expect(result).toEqual([{
+//             columnNumber: 7,
+//             lineNumber: 1,
+//             context: content,
+//             isStatic: true,
+//             match: {
+//                 value: 'This is a sentence'
+//             }
+//         }]);
+//     });
+//     it('should extract strings from attribute bindings', () => {
+//         const content = '<my-component [label]="\'This is a label\' | translate"></my-component>';
+//         const parser = new AngularHTMLDetector(console);
+//         const result = parser.detect(content);
+//         expect(result).toEqual([{
+//             columnNumber: 14,
+//             lineNumber: 1,
+//             context: content,
+//             isStatic: true,
+//             match: {
+//                 value: 'This is a label'
+//             }
+//         }]);
+//     });
+//     it('should extract strings from event bindings', () => {
+//         const content = '<button (click)="doSomething(\'This is a key\' | translate)">Click Me</button>';
+//         const parser = new AngularHTMLDetector(console);
+//         const result = parser.detect(content);
+//         expect(result).toEqual([{
+//             columnNumber: 8,
+//             lineNumber: 1,
+//             context: content,
+//             isStatic: true,
+//             match: {
+//                 value: 'This is a key'
+//             }
+//         }]);
+//     });
+//     it('should extract strings from structural directives', () => {
+//         const content = `<div *ngIf="'This is a condition' | translate as conditionText">
+//             {{ conditionText }}
+//         </div>`;
+//         const parser = new AngularHTMLDetector(console);
+//         const result = parser.detect(content);
+//         expect(result).toEqual([{
+//             columnNumber: 5,
+//             lineNumber: 1,
+//             context: '<div *ngIf="\'This is a condition\' | translate as conditionText">',
+//             isStatic: true,
+//             match: {
+//                 value: 'This is a condition'
+//             }
+//         }]);
+//     });
+//     it('should extract strings from JSON-like configurations', () => {
+//         const content = '<div [config]="{ label: \'This is a translatable label\' | translate }"></div>';
+//         const parser = new AngularHTMLDetector(console);
+//         const result = parser.detect(content);
+//         expect(result).toEqual([{
+//             columnNumber: 5,
+//             lineNumber: 1,
+//             context: content,
+//             isStatic: true,
+//             match: {
+//                 value: 'This is a translatable label'
+//             }
+//         }]);
+//     });
+//     it('should extract strings from content projection', () => {
+//         const content = '<ng-content select="[label]">{{ \'Default translation\' | translate }}</ng-content>';
+//         const parser = new AngularHTMLDetector(console);
+//         const result = parser.detect(content);
+//         expect(result).toEqual([{
+//             columnNumber: 29,
+//             lineNumber: 1,
+//             context: content,
+//             isStatic: true,
+//             match: {
+//                 value: 'Default translation'
+//             }
+//         }]);
+//     });
+//     it('should return an empty array for empty content', () => {
+//         const parser = new AngularHTMLDetector(console);
+//         const result = parser.detect('');
+//         expect(result).toEqual([]);
+//     });
+// });
+//# sourceMappingURL=AngularHTMLParser.Test.js.map

package/_tests/AngularHTMLParser.Test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AngularHTMLParser.Test.js","sourceRoot":"","sources":["../../src/_tests/AngularHTMLParser.Test.ts"],"names":[],"mappings":";AAAA,qBAAqB;AAErB,8EAA8E;AAC9E,iDAAiD;AAEjD,gBAAgB;AAEhB,wCAAwC;AACxC,mEAAmE;AACnE,qFAAqF;AACrF,2DAA2D;AAC3D,iDAAiD;AAEjD,oCAAoC;AACpC,+BAA+B;AAC/B,6BAA6B;AAC7B,gCAAgC;AAChC,8BAA8B;AAC9B,uBAAuB;AACvB,8CAA8C;AAC9C,gBAAgB;AAChB,eAAe;AACf,UAAU;AAEV,mEAAmE;AACnE,qGAAqG;AACrG,2DAA2D;AAC3D,iDAAiD;AAEjD,oCAAoC;AACpC,gCAAgC;AAChC,6BAA6B;AAC7B,gCAAgC;AAChC,8BAA8B;AAC9B,uBAAuB;AACvB,2CAA2C;AAC3C,gBAAgB;AAChB,eAAe;AACf,UAAU;AAEV,+DAA+D;AAC/D,4GAA4G;AAC5G,2DAA2D;AAC3D,iDAAiD;AAEjD,oCAAoC;AACpC,+BAA+B;AAC/B,6BAA6B;AAC7B,gCAAgC;AAChC,8BAA8B;AAC9B,uBAAuB;AACvB,yCAAyC;AACzC,gBAAgB;AAChB,eAAe;AACf,UAAU;AAEV,sEAAsE;AACtE,4FAA4F;AAC5F,kCAAkC;AAClC,mBAAmB;AACnB,2DAA2D;AAC3D,iDAAiD;AAEjD,oCAAoC;AACpC,+BAA+B;AAC/B,6BAA6B;AAC7B,6FAA6F;AAC7F,8BAA8B;AAC9B,uBAAuB;AACvB,+CAA+C;AAC/C,gBAAgB;AAChB,eAAe;AACf,UAAU;AAEV,yEAAyE;AACzE,4GAA4G;AAC5G,2DAA2D;AAC3D,iDAAiD;AAEjD,oCAAoC;AACpC,+BAA+B;AAC/B,6BAA6B;AAC7B,gCAAgC;AAChC,8BAA8B;AAC9B,uBAAuB;AACvB,wDAAwD;AACxD,gBAAgB;AAChB,eAAe;AACf,UAAU;AAEV,mEAAmE;AACnE,iHAAiH;AACjH,2DAA2D;AAC3D,iDAAiD;AAEjD,oCAAoC;AACpC,gCAAgC;AAChC,6BAA6B;AAC7B,gCAAgC;AAChC,8BAA8B;AAC9B,uBAAuB;AACvB,+CAA+C;AAC/C,gBAAgB;AAChB,eAAe;AACf,UAAU;AAEV,mEAAmE;AACnE,2DAA2D;AAC3D,4CAA4C;AAE5C,sCAAsC;AACtC,UAAU;AACV,MAAM"}

package/_tests/AngularPreset.Test.d.ts

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

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

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

package/_tests/AngularPreset.Test.js

@@ -0,0 +1,14 @@
+"use strict";
+// import { describe, it, expect } from 'vitest';
+// import { AngularPreset } from '../src/Presets/AngularPreset';
+// import { AngularHTMLDetector } from '../src/Detectors/AngularHTMLDetector';
+// import { TypeScriptDetector } from '../src/Detectors/TypeScriptDetector';
+// describe('AngularPreset', () => {
+//     it('should return correct parsers for file extensions', () => {
+//         const preset = new AngularPreset(console);
+//         const parsers = preset.getParsers();
+//         expect(parsers['.html']).toBeInstanceOf(AngularHTMLDetector);
+//         expect(parsers['.ts']).toBeInstanceOf(TypeScriptDetector);
+//     });
+// });
+//# sourceMappingURL=AngularPreset.Test.js.map

package/_tests/AngularPreset.Test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AngularPreset.Test.js","sourceRoot":"","sources":["../../src/_tests/AngularPreset.Test.ts"],"names":[],"mappings":";AAAA,iDAAiD;AACjD,gEAAgE;AAChE,8EAA8E;AAC9E,4EAA4E;AAE5E,oCAAoC;AACpC,sEAAsE;AACtE,qDAAqD;AACrD,+CAA+C;AAE/C,wEAAwE;AACxE,qEAAqE;AACrE,UAAU;AACV,MAAM"}

package/_tests/DuplicateKeysTask.Test.d.ts

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

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

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

package/_tests/DuplicateKeysTask.Test.js

@@ -0,0 +1,97 @@
+"use strict";
+// // #region Imports
+// import { describe, it, expect } from 'vitest';
+// import { DuplicateKeysTask } from '../src/Resources/Analyzers/Tasks/DuplicateKeysTask';
+// import { JsonResourceInfo } from '../src/Resources/Models/JsonResourceInfo';
+// import type { IAnalyzerTaskExecutionContext } from '../src/Resources/Analyzers/Tasks/Interfaces/IAnalyzerTask';
+// // #endregion
+// describe('DuplicateKeysTask', () => {
+//     it('should return no duplicates for unique keys', () => {
+//         const task = new DuplicateKeysTask();
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [
+//                 new JsonResourceInfo({
+//                     locale: 'en',
+//                     data: {
+//                         key1: 'value1',
+//                         key2: 'value2',
+//                         key3: 'value3'
+//                     }
+//                 }),
+//                 new JsonResourceInfo({
+//                     locale: 'de',
+//                     data: {
+//                         keyA: 'wertA',
+//                         keyB: 'wertB',
+//                         keyC: 'wertC'
+//                     }
+//                 })
+//             ],
+//             parameters: {}
+//         };
+//         const result = task.execute(context);
+//         expect(result.success).toBe(true);
+//         expect(result.message).toBe('No duplicate keys found in resources.');
+//         expect(result.data).toEqual([]);
+//     });
+//     it('should detect duplicates in a single resource', () => {
+//         const task = new DuplicateKeysTask(console);
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [
+//                 new JsonResourceInfo({
+//                     locale: 'en',
+//                     data: {
+//                         key1: 'value1',
+//                         key2: 'value2'
+//                         // key1: 'value3'
+//                     } // Duplicate: 'key1'
+//                 })
+//             ],
+//             parameters: {}
+//         };
+//         const result = task.execute(context);
+//         expect(result.success).toBe(true);
+//         expect(result.message).toBe('No duplicate keys found in resources.');
+//         expect(result.data).toEqual([]);
+//     });
+//     it('should detect duplicates across multiple resources', () => {
+//         const task = new DuplicateKeysTask(console);
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [
+//                 new JsonResourceInfo({
+//                     locale: 'en',
+//                     data: {
+//                         key1: 'value1',
+//                         key2: 'value2'
+//                         // key1: 'value3'
+//                     } // Duplicate: 'key1'
+//                 }),
+//                 new JsonResourceInfo({
+//                     locale: 'de',
+//                     data: {
+//                         keyA: 'wertA',
+//                         keyB: 'wertB'
+//                         // keyA: 'wertC'
+//                     } // Duplicate: 'keyA'
+//                 })
+//             ],
+//             parameters: {}
+//         };
+//         const result = task.execute(context);
+//         expect(result.success).toBe(true);
+//         expect(result.message).toBe('No duplicate keys found in resources.');
+//         expect(result.data).toEqual([]);
+//     });
+//     it('should handle empty resources without issues', () => {
+//         const task = new DuplicateKeysTask(console);
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [],
+//             parameters: {}
+//         };
+//         const result = task.execute(context);
+//         expect(result.success).toBe(true);
+//         expect(result.message).toBe('No duplicate keys found in resources.');
+//         expect(result.data).toEqual([]);
+//     });
+// });
+//# sourceMappingURL=DuplicateKeysTask.Test.js.map

package/_tests/DuplicateKeysTask.Test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DuplicateKeysTask.Test.js","sourceRoot":"","sources":["../../src/_tests/DuplicateKeysTask.Test.ts"],"names":[],"mappings":";AAAA,qBAAqB;AAErB,iDAAiD;AACjD,0FAA0F;AAC1F,+EAA+E;AAC/E,kHAAkH;AAElH,gBAAgB;AAEhB,wCAAwC;AACxC,gEAAgE;AAChE,gDAAgD;AAChD,2DAA2D;AAC3D,2BAA2B;AAC3B,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,0CAA0C;AAC1C,0CAA0C;AAC1C,yCAAyC;AACzC,wBAAwB;AACxB,sBAAsB;AACtB,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,yCAAyC;AACzC,yCAAyC;AACzC,wCAAwC;AACxC,wBAAwB;AACxB,qBAAqB;AACrB,iBAAiB;AACjB,6BAA6B;AAC7B,aAAa;AAEb,gDAAgD;AAEhD,6CAA6C;AAC7C,gFAAgF;AAChF,2CAA2C;AAC3C,UAAU;AAEV,kEAAkE;AAClE,uDAAuD;AACvD,2DAA2D;AAC3D,2BAA2B;AAC3B,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,0CAA0C;AAC1C,yCAAyC;AACzC,4CAA4C;AAC5C,6CAA6C;AAC7C,qBAAqB;AACrB,iBAAiB;AACjB,6BAA6B;AAC7B,aAAa;AAEb,gDAAgD;AAEhD,6CAA6C;AAC7C,gFAAgF;AAChF,2CAA2C;AAC3C,UAAU;AAEV,uEAAuE;AACvE,uDAAuD;AACvD,2DAA2D;AAC3D,2BAA2B;AAC3B,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,0CAA0C;AAC1C,yCAAyC;AACzC,4CAA4C;AAC5C,6CAA6C;AAC7C,sBAAsB;AACtB,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,yCAAyC;AACzC,wCAAwC;AACxC,2CAA2C;AAC3C,6CAA6C;AAC7C,qBAAqB;AACrB,iBAAiB;AACjB,6BAA6B;AAC7B,aAAa;AAEb,gDAAgD;AAEhD,6CAA6C;AAC7C,gFAAgF;AAChF,2CAA2C;AAC3C,UAAU;AAEV,iEAAiE;AACjE,uDAAuD;AACvD,2DAA2D;AAC3D,6BAA6B;AAC7B,6BAA6B;AAC7B,aAAa;AAEb,gDAAgD;AAEhD,6CAA6C;AAC7C,gFAAgF;AAChF,2CAA2C;AAC3C,UAAU;AACV,MAAM"}

package/_tests/EmptyValuesTask.Test.d.ts

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

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

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

package/_tests/EmptyValuesTask.Test.js

@@ -0,0 +1,87 @@
+"use strict";
+// // #region Imports
+// import { describe, it, expect } from 'vitest';
+// import { EmptyValuesTask } from '../src/Resources/Analyzers/Tasks/EmptyValuesTask';
+// import type { IAnalyzerTaskExecutionContext } from '../src/Resources/Analyzers/Tasks/Interfaces/IAnalyzerTask';
+// import { JsonResourceInfo } from '../src/Resources/Models/JsonResourceInfo';
+// // #endregion
+// describe('EmptyValuesTask', () => {
+//     it('should identify empty values in resources', () => {
+//         const task = new EmptyValuesTask();
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [
+//                 new JsonResourceInfo({
+//                     locale: 'en',
+//                     data: {
+//                         key1: 'value1',
+//                         key2: '', // Empty value
+//                         key3: 'value3',
+//                         key4: null // Empty value
+//                     }
+//                 }),
+//                 new JsonResourceInfo({
+//                     locale: 'de',
+//                     data: {
+//                         keyA: 'wertA',
+//                         keyB: '', // Empty value
+//                         keyC: 'wertC'
+//                     }
+//                 })
+//             ],
+//             parameters: {}
+//         };
+//         const result = task.execute(context);
+//         expect(result.success).toBe(false);
+//         expect(result.message).toBe('Empty values found in resources.');
+//         expect(result.data).toEqual([
+//             {
+//                 locale: 'en',
+//                 keys: ['key2', 'key4']
+//             },
+//             {
+//                 locale: 'de',
+//                 keys: ['keyB']
+//             }
+//         ]);
+//     });
+//     it('should return success when no empty values are found', () => {
+//         const task = new EmptyValuesTask(console);
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [
+//                 new JsonResourceInfo({
+//                     locale: 'en',
+//                     data: {
+//                         key1: 'value1',
+//                         key2: 'value2',
+//                         key3: 'value3'
+//                     }
+//                 }),
+//                 new JsonResourceInfo({
+//                     locale: 'de',
+//                     data: {
+//                         keyA: 'wertA',
+//                         keyB: 'wertB',
+//                         keyC: 'wertC'
+//                     }
+//                 })
+//             ],
+//             parameters: {}
+//         };
+//         const result = task.execute(context);
+//         expect(result.success).toBe(true);
+//         expect(result.message).toBe('No empty values found.');
+//         expect(result.data).toEqual([]);
+//     });
+//     it('should handle empty resource list', () => {
+//         const task = new EmptyValuesTask(console);
+//         const context: IAnalyzerTaskExecutionContext = {
+//             resources: [],
+//             parameters: {}
+//         };
+//         const result = task.execute(context);
+//         expect(result.success).toBe(true);
+//         expect(result.message).toBe('No empty values found.');
+//         expect(result.data).toEqual([]);
+//     });
+// });
+//# sourceMappingURL=EmptyValuesTask.Test.js.map

package/_tests/EmptyValuesTask.Test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmptyValuesTask.Test.js","sourceRoot":"","sources":["../../src/_tests/EmptyValuesTask.Test.ts"],"names":[],"mappings":";AACA,qBAAqB;AAErB,iDAAiD;AACjD,sFAAsF;AACtF,kHAAkH;AAClH,+EAA+E;AAE/E,gBAAgB;AAEhB,sCAAsC;AACtC,8DAA8D;AAC9D,8CAA8C;AAC9C,2DAA2D;AAC3D,2BAA2B;AAC3B,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,0CAA0C;AAC1C,mDAAmD;AACnD,0CAA0C;AAC1C,oDAAoD;AACpD,wBAAwB;AACxB,sBAAsB;AACtB,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,yCAAyC;AACzC,mDAAmD;AACnD,wCAAwC;AACxC,wBAAwB;AACxB,qBAAqB;AACrB,iBAAiB;AACjB,6BAA6B;AAC7B,aAAa;AAEb,gDAAgD;AAEhD,8CAA8C;AAC9C,2EAA2E;AAC3E,wCAAwC;AACxC,gBAAgB;AAChB,gCAAgC;AAChC,yCAAyC;AACzC,iBAAiB;AACjB,gBAAgB;AAChB,gCAAgC;AAChC,iCAAiC;AACjC,gBAAgB;AAChB,cAAc;AACd,UAAU;AAEV,yEAAyE;AACzE,qDAAqD;AACrD,2DAA2D;AAC3D,2BAA2B;AAC3B,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,0CAA0C;AAC1C,0CAA0C;AAC1C,yCAAyC;AACzC,wBAAwB;AACxB,sBAAsB;AACtB,yCAAyC;AACzC,oCAAoC;AACpC,8BAA8B;AAC9B,yCAAyC;AACzC,yCAAyC;AACzC,wCAAwC;AACxC,wBAAwB;AACxB,qBAAqB;AACrB,iBAAiB;AACjB,6BAA6B;AAC7B,aAAa;AAEb,gDAAgD;AAEhD,6CAA6C;AAC7C,iEAAiE;AACjE,2CAA2C;AAC3C,UAAU;AAEV,sDAAsD;AACtD,qDAAqD;AACrD,2DAA2D;AAC3D,6BAA6B;AAC7B,6BAA6B;AAC7B,aAAa;AAEb,gDAAgD;AAEhD,6CAA6C;AAC7C,iEAAiE;AACjE,2CAA2C;AAC3C,UAAU;AACV,MAAM"}

package/_tests/JSXParser.Test.d.ts

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

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

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

package/_tests/JSXParser.Test.js

@@ -0,0 +1,94 @@
+"use strict";
+// // #region Imports
+// import { describe, it, expect, vi } from 'vitest';
+// import { JSXParser } from '../src/Parsers/JSXParser.js';
+// // #endregion
+// describe('JSXParser', () => {
+//     it('should parse simple translations', () => {
+//         const parser = new JSXParser(console);
+//         const content = 't("Simple string"); translate(\'Another string\');';
+//         const result = parser.parse(content);
+//         expect(result).toEqual(['Simple string', 'Another string']);
+//     });
+//     it('should parse template literals', () => {
+//         const parser = new JSXParser(console);
+//         const content = 't(`Template literal string`);';
+//         const result = parser.parse(content);
+//         expect(result).toEqual(['Template literal string']);
+//     });
+//     it('should normalize multiline strings', () => {
+//         const parser = new JSXParser(console);
+//         const content = 't("This is a multiline string");';
+//         const result = parser.parse(content);
+//         expect(result).toEqual(['This is a multiline string']);
+//     });
+//     it('should parse translations with context', () => {
+//         const parser = new JSXParser(console);
+//         const content = 't("This is translatable", { context: "example" });';
+//         const result = parser.parse(content);
+//         expect(result).toEqual(['This is translatable']);
+//     });
+//     it('should handle custom markers as strings', () => {
+//         const parser = new JSXParser(console, { marker: 'customTranslate' });
+//         const content = 'customTranslate("Custom string");';
+//         const result = parser.parse(content);
+//         expect(result).toEqual(['Custom string']);
+//     });
+//     it('should handle custom markers as regex', () => {
+//         const parser = new JSXParser(console, { marker: /custom|translate/ });
+//         const content = `
+//             custom("Custom function");
+//             translate("Translated string");
+//         `;
+//         const result = parser.parse(content);
+//         expect(result).toEqual(['Custom function', 'Translated string']);
+//     });
+//     it('should handle escaped quotes', () => {
+//         const parser = new JSXParser(console);
+//         const content = 't("Escaped \\"quote\\""); translate(\'Escaped \\\'quote\\\'\');';
+//         const result = parser.parse(content);
+//         expect(result).toEqual(['Escaped "quote"', "Escaped 'quote'"]);
+//     });
+//     it('should handle empty content gracefully', () => {
+//         const parser = new JSXParser(console);
+//         const result = parser.parse('');
+//         expect(result).toEqual([]);
+//     });
+//     it('should handle null content gracefully', () => {
+//         const parser = new JSXParser(console);
+//         const result = parser.parse(null as any);
+//         expect(result).toEqual([]);
+//     });
+//     it('should handle undefined content gracefully', () => {
+//         const parser = new JSXParser(console);
+//         const result = parser.parse(undefined as any);
+//         expect(result).toEqual([]);
+//     });
+//     it('should trim results during post-processing', () => {
+//         const parser = new JSXParser(console);
+//         const content = 't("   String with spaces   ");';
+//         const result = parser.parse(content);
+//         expect(result).toEqual(['String with spaces']);
+//     });
+//     it('should parse multiple translations in one line', () => {
+//         const parser = new JSXParser(console);
+//         const content = 't("First string"); t("Second string");';
+//         const result = parser.parse(content);
+//         expect(result).toEqual(['First string', 'Second string']);
+//     });
+//     it('should log debug messages when debug is enabled', () => {
+//         const consoleSpy = vi.spyOn(console, 'debug').mockImplementation(() => { });
+//         const parser = new JSXParser(console, { debug: true });
+//         const content = 't("Debug string");';
+//         parser.parse(content);
+//         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[BaseParser]:'));
+//         consoleSpy.mockRestore();
+//     });
+//     it('should not match invalid function calls', () => {
+//         const parser = new JSXParser(console);
+//         const content = 't(); t("Valid string"); translate();';
+//         const result = parser.parse(content);
+//         expect(result).toEqual(['Valid string']);
+//     });
+// });
+//# sourceMappingURL=JSXParser.Test.js.map

package/_tests/JSXParser.Test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSXParser.Test.js","sourceRoot":"","sources":["../../src/_tests/JSXParser.Test.ts"],"names":[],"mappings":";AAAA,qBAAqB;AAErB,qDAAqD;AACrD,2DAA2D;AAE3D,gBAAgB;AAEhB,gCAAgC;AAChC,qDAAqD;AACrD,iDAAiD;AACjD,gFAAgF;AAChF,gDAAgD;AAChD,uEAAuE;AACvE,UAAU;AAEV,mDAAmD;AACnD,iDAAiD;AACjD,2DAA2D;AAC3D,gDAAgD;AAChD,+DAA+D;AAC/D,UAAU;AAEV,uDAAuD;AACvD,iDAAiD;AACjD,8DAA8D;AAC9D,gDAAgD;AAChD,kEAAkE;AAClE,UAAU;AAEV,2DAA2D;AAC3D,iDAAiD;AACjD,gFAAgF;AAChF,gDAAgD;AAChD,4DAA4D;AAC5D,UAAU;AAEV,4DAA4D;AAC5D,gFAAgF;AAChF,+DAA+D;AAC/D,gDAAgD;AAChD,qDAAqD;AACrD,UAAU;AAEV,0DAA0D;AAC1D,iFAAiF;AACjF,4BAA4B;AAC5B,yCAAyC;AACzC,8CAA8C;AAC9C,aAAa;AACb,gDAAgD;AAChD,4EAA4E;AAC5E,UAAU;AAEV,iDAAiD;AACjD,iDAAiD;AACjD,6FAA6F;AAC7F,gDAAgD;AAChD,0EAA0E;AAC1E,UAAU;AAEV,2DAA2D;AAC3D,iDAAiD;AACjD,2CAA2C;AAC3C,sCAAsC;AACtC,UAAU;AAEV,0DAA0D;AAC1D,iDAAiD;AACjD,oDAAoD;AACpD,sCAAsC;AACtC,UAAU;AAEV,+DAA+D;AAC/D,iDAAiD;AACjD,yDAAyD;AACzD,sCAAsC;AACtC,UAAU;AAEV,+DAA+D;AAC/D,iDAAiD;AACjD,4DAA4D;AAC5D,gDAAgD;AAChD,0DAA0D;AAC1D,UAAU;AAEV,mEAAmE;AACnE,iDAAiD;AACjD,oEAAoE;AACpE,gDAAgD;AAChD,qEAAqE;AACrE,UAAU;AAEV,oEAAoE;AACpE,uFAAuF;AACvF,kEAAkE;AAClE,gDAAgD;AAChD,iCAAiC;AACjC,6FAA6F;AAC7F,oCAAoC;AACpC,UAAU;AAEV,4DAA4D;AAC5D,iDAAiD;AACjD,kEAAkE;AAClE,gDAAgD;AAChD,oDAAoD;AACpD,UAAU;AACV,MAAM"}

package/_tests/JavaScriptParser.Test.d.ts

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

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

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