@l10nmonster/helpers-java 3.0.0-alpha.9 → 3.0.2

package/CHANGELOG.md

@@ -1,3 +1,27 @@
+## @l10nmonster/helpers-java [3.0.2](https://public-github/l10nmonster/l10nmonster/compare/@l10nmonster/helpers-java@3.0.1...@l10nmonster/helpers-java@3.0.2) (2025-12-23)
+
+
+### Bug Fixes
+
+* Improve type definitions and checks ([826b412](https://public-github/l10nmonster/l10nmonster/commit/826b412f0f7e761d404165a243b0c2b26c416ac1))
+
+
+
+
+
+### Dependencies
+
+* **@l10nmonster/core:** upgraded to 3.1.1
+
+## @l10nmonster/helpers-java [3.0.1](https://public-github/l10nmonster/l10nmonster/compare/@l10nmonster/helpers-java@3.0.0...@l10nmonster/helpers-java@3.0.1) (2025-12-20)
+
+
+### Bug Fixes
+
+* Add proper pluralization expansion support ([3d062bb](https://public-github/l10nmonster/l10nmonster/commit/3d062bbb3272c61e969b419a56a7a5e347ab96c6))
+* Pluralization improvements ([5964250](https://public-github/l10nmonster/l10nmonster/commit/596425092c425cc8d6c312ef58509c4c3c537431))
+* **server:** Fix cart cleanup ([9bbcab9](https://public-github/l10nmonster/l10nmonster/commit/9bbcab93e1fd20aeb09f59c828665159f091f37c))
+
 # Changelog
 
 All notable changes to this project will be documented in this file.

package/filter.js

@@ -1,10 +1,27 @@
 import { parseToEntries, stringifyFromEntries } from '@js.properties/properties';
 
+/** @typedef {import('@l10nmonster/core').ResourceFilter} ResourceFilter */
+
+/**
+ * Filter for Java .properties files.
+ * @implements {ResourceFilter}
+ */
 export default class JavaPropertiesFilter {
-    async parseResource({ resource }) {
+
+    /**
+     * @param {Object} [params] - Configuration options
+     * @param {boolean} [params.enablePluralizationSuffixes=false] - Enable detection of plural forms via key suffixes (_one, _other, etc.)
+     */
+    constructor(params) {
+        this.enablePluralizationSuffixes = params?.enablePluralizationSuffixes || false;
+    }
+
+    async parseResource({ resource, sourcePluralForms, targetPluralForms }) {
         const parsedResource = parseToEntries(resource, { sep: true, eol: true, all: true, original: true, location: true });
         const segments = [];
         let previousComments = [];
+
+        // First pass: collect all segments
         for (const e of parsedResource) {
             if (e.key && e.sep.trim() === '=') {
                 const location = {startLine: e.location.start.line, endLine: e.location.end.line}
@@ -30,24 +47,192 @@ export default class JavaPropertiesFilter {
                 e.original.trim().length > 0 && previousComments.push(e.original);
             }
         }
+
+        // Second pass: detect and mark plural forms (only if enabled)
+        if (this.enablePluralizationSuffixes) {
+            const targetFormsSet = new Set(targetPluralForms);
+            const potentialPluralGroups = new Map(); // baseKey -> Map(suffix -> segment)
+
+            for (const seg of segments) {
+                const underscoreIdx = seg.sid.lastIndexOf('_');
+                if (underscoreIdx !== -1) {
+                    const suffix = seg.sid.slice(underscoreIdx + 1);
+                    if (targetFormsSet.has(suffix)) {
+                        const baseKey = seg.sid.slice(0, underscoreIdx);
+                        if (!potentialPluralGroups.has(baseKey)) {
+                            potentialPluralGroups.set(baseKey, new Map());
+                        }
+                        potentialPluralGroups.get(baseKey).set(suffix, seg);
+                    }
+                }
+            }
+
+            // For groups with all required source forms: set pluralForm and generate missing forms
+            // We need to reorder segments so all forms of a plural group are together in CLDR order
+            const pluralGroupsToReorder = new Map(); // baseKey -> forms Map
+
+            for (const [baseKey, forms] of potentialPluralGroups) {
+                const hasAllForms = sourcePluralForms.every(form => forms.has(form));
+                if (!hasAllForms) continue;
+
+                // Set pluralForm on existing segments
+                for (const [suffix, seg] of forms) {
+                    seg.pluralForm = suffix;
+                }
+
+                // Generate missing forms from _other
+                const other = forms.get('other');
+                for (const suffix of targetPluralForms) {
+                    if (!forms.has(suffix)) {
+                        forms.set(suffix, {
+                            sid: `${baseKey}_${suffix}`,
+                            str: other.str,
+                            pluralForm: suffix,
+                            ...(other.notes && { notes: other.notes }),
+                            ...(other.location && { location: other.location })
+                        });
+                    }
+                }
+
+                pluralGroupsToReorder.set(baseKey, forms);
+            }
+
+            // Rebuild segments with plural groups in correct order
+            if (pluralGroupsToReorder.size > 0) {
+                const newSegments = [];
+                const processedPluralKeys = new Set();
+
+                for (const seg of segments) {
+                    const underscoreIdx = seg.sid.lastIndexOf('_');
+                    const suffix = underscoreIdx !== -1 ? seg.sid.slice(underscoreIdx + 1) : null;
+                    const baseKey = underscoreIdx !== -1 ? seg.sid.slice(0, underscoreIdx) : null;
+
+                    if (baseKey && pluralGroupsToReorder.has(baseKey) && !processedPluralKeys.has(baseKey)) {
+                        // Insert all forms of this plural group in CLDR order
+                        processedPluralKeys.add(baseKey);
+                        const forms = pluralGroupsToReorder.get(baseKey);
+                        for (const form of targetPluralForms) {
+                            if (forms.has(form)) {
+                                newSegments.push(forms.get(form));
+                            }
+                        }
+                    } else if (!baseKey || !pluralGroupsToReorder.has(baseKey)) {
+                        // Non-plural segment
+                        newSegments.push(seg);
+                    }
+                    // Skip plural segments that were already added via the group
+                }
+
+                return { segments: newSegments };
+            }
+        }
+
         return {
             segments,
         };
     }
 
-    async translateResource({ resource, translator }) {
+    async translateResource({ resource, translator, sourcePluralForms, targetPluralForms }) {
         const parsedResource = parseToEntries(resource, { sep: true, eol: true, all: true, original: true });
         const translatedEntries = [];
-        for (const entry of parsedResource) {
-            if (entry.key) {
-                const translation = await translator(entry.key, entry.element);
-                if (translation !== undefined) {
-                    // eslint-disable-next-line no-unused-vars
-                    const { original, element, ...rest } = entry;
-                    translatedEntries.push({
-                        ...rest,
-                        element: translation,
-                    })
+
+        if (this.enablePluralizationSuffixes) {
+            const targetFormsSet = new Set(targetPluralForms);
+
+            // First pass: identify plural groups and collect entries
+            const potentialPluralGroups = new Map(); // baseKey -> Map(suffix -> entry)
+
+            for (const entry of parsedResource) {
+                if (entry.key) {
+                    const underscoreIdx = entry.key.lastIndexOf('_');
+                    if (underscoreIdx !== -1) {
+                        const suffix = entry.key.slice(underscoreIdx + 1);
+                        if (targetFormsSet.has(suffix)) {
+                            const baseKey = entry.key.slice(0, underscoreIdx);
+                            if (!potentialPluralGroups.has(baseKey)) {
+                                potentialPluralGroups.set(baseKey, new Map());
+                            }
+                            potentialPluralGroups.get(baseKey).set(suffix, entry);
+                        }
+                    }
+                }
+            }
+
+            // Identify valid plural groups (those with all required source forms)
+            const validPluralBaseKeys = new Set();
+            for (const [baseKey, forms] of potentialPluralGroups) {
+                const hasAllForms = sourcePluralForms.every(form => forms.has(form));
+                if (hasAllForms) {
+                    validPluralBaseKeys.add(baseKey);
+                }
+            }
+
+            // Second pass: translate entries and handle plurals
+            const processedPluralGroups = new Set();
+
+            for (const entry of parsedResource) {
+                if (entry.key) {
+                    const underscoreIdx = entry.key.lastIndexOf('_');
+                    const suffix = underscoreIdx !== -1 ? entry.key.slice(underscoreIdx + 1) : null;
+                    const baseKey = underscoreIdx !== -1 ? entry.key.slice(0, underscoreIdx) : null;
+
+                    // Check if this is part of a valid plural group
+                    if (baseKey && validPluralBaseKeys.has(baseKey) && targetFormsSet.has(suffix)) {
+                        // Skip if we already processed this plural group
+                        if (processedPluralGroups.has(baseKey)) {
+                            continue;
+                        }
+                        processedPluralGroups.add(baseKey);
+
+                        // Get the _other form as template for generating missing forms
+                        const otherEntry = potentialPluralGroups.get(baseKey).get('other');
+                        const templateEntry = otherEntry || entry;
+
+                        // Generate all required target forms
+                        for (const targetSuffix of targetPluralForms) {
+                            const targetKey = `${baseKey}_${targetSuffix}`;
+                            const sourceEntry = potentialPluralGroups.get(baseKey).get(targetSuffix) || otherEntry;
+
+                            if (sourceEntry) {
+                                const translation = await translator(targetKey, sourceEntry.element);
+                                if (translation !== undefined) {
+                                    // eslint-disable-next-line no-unused-vars
+                                    const { original, element, key, ...rest } = templateEntry;
+                                    translatedEntries.push({
+                                        ...rest,
+                                        key: targetKey,
+                                        element: translation,
+                                    });
+                                }
+                            }
+                        }
+                    } else {
+                        // Regular (non-plural) entry
+                        const translation = await translator(entry.key, entry.element);
+                        if (translation !== undefined) {
+                            // eslint-disable-next-line no-unused-vars
+                            const { original, element, ...rest } = entry;
+                            translatedEntries.push({
+                                ...rest,
+                                element: translation,
+                            });
+                        }
+                    }
+                }
+            }
+        } else {
+            // Simple translation without plural handling
+            for (const entry of parsedResource) {
+                if (entry.key) {
+                    const translation = await translator(entry.key, entry.element);
+                    if (translation !== undefined) {
+                        // eslint-disable-next-line no-unused-vars
+                        const { original, element, ...rest } = entry;
+                        translatedEntries.push({
+                            ...rest,
+                            element: translation,
+                        });
+                    }
                 }
             }
         }

package/index.js

@@ -9,6 +9,8 @@ const javaControlCharsToDecode = {
     r: '\r',
     f: '\f',
 };
+
+/** @type {import('@l10nmonster/core').DecoderFunction} */
 export const escapesDecoder = regex.decoderMaker(
     'javaEscapesDecoder',
     /(?<node>\\(?<escapedChar>['"\\])|\\(?<escapedControl>[tbnrf])|\\u(?<codePoint>[0-9A-Za-z]{4}))/g,
@@ -21,6 +23,7 @@ export const escapesDecoder = regex.decoderMaker(
 );
 
 // TODO: do we need to escape also those escapedChar that we decoded?
+/** @type {import('@l10nmonster/core').TextEncoderFunction} */
 export const escapesEncoder = regex.encoderMaker(
     'javaEscapesEncoder',
     // eslint-disable-next-line prefer-named-capture-group
@@ -34,6 +37,7 @@ export const escapesEncoder = regex.encoderMaker(
     }
 );
 
+/** @type {import('@l10nmonster/core').DecoderFunction} */
 export const MFQuotesDecoder = regex.decoderMaker(
     'javaMFQuotesDecoder',
     /(?:(?<quote>')'|(?:'(?<quoted>[^']+)'))/g,
@@ -41,6 +45,7 @@ export const MFQuotesDecoder = regex.decoderMaker(
 );
 
 // need to be smart about detecting whether MessageFormat was used or not based on presence of {vars}
+/** @type {import('@l10nmonster/core').TextEncoderFunction} */
 export const MFQuotesEncoder = regex.encoderMaker(
     'javaMFQuotesEncoder',
     // eslint-disable-next-line prefer-named-capture-group

package/package.json

@@ -1,11 +1,12 @@
 {
     "name": "@l10nmonster/helpers-java",
-    "version": "3.0.0-alpha.9",
+    "version": "3.0.2",
     "description": "Helpers to deal with Java file formats",
     "type": "module",
     "main": "index.js",
     "scripts": {
-        "test": "node --test"
+        "test": "node --test",
+        "typecheck": "tsc --noEmit"
     },
     "author": "Diego Lagunas",
     "license": "MIT",
@@ -13,6 +14,6 @@
         "@js.properties/properties": "^0.5.4"
     },
     "peerDependencies": {
-        "@l10nmonster/core": "^3.0.0-alpha.0"
+        "@l10nmonster/core": "3.1.1"
     }
 }

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "extends": "../tsconfig.base.json",
+  "include": [
+    "*.js",
+    "**/*.js"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/node_modules",
+    "test/**",
+    "tests/**",
+    "**/*.test.js",
+    "**/*.spec.js",
+    "dist/**",
+    "ui/**",
+    "types/**"
+  ]
+}

package/.releaserc.json

@@ -1,31 +0,0 @@
-{
-  "branches": [
-    "main",
-    {
-      "name": "next",
-      "prerelease": "alpha"
-    },
-    {
-      "name": "beta",
-      "prerelease": "beta"
-    }
-  ],
-  "tagFormat": "@l10nmonster/helpers-java@${version}",
-  "plugins": [
-    "@semantic-release/commit-analyzer",
-    "@semantic-release/release-notes-generator",
-    {
-      "path": "@semantic-release/changelog",
-      "changelogFile": "CHANGELOG.md"
-    },
-    {
-      "path": "@semantic-release/npm",
-      "npmPublish": true
-    },
-    {
-      "path": "@semantic-release/git",
-      "assets": ["CHANGELOG.md", "package.json"],
-      "message": "chore(release): @l10nmonster/helpers-java@${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
-    }
-  ]
-}