@l10nmonster/helpers-java 1.0.0

package/README.md

@@ -0,0 +1,18 @@
+# L10n Monster Java Helpers
+
+|Module|Export|Description|
+|---|---|---|
+|`helpers-java`|`escapesDecoder`|Decoder for escaped chars like `\n` and `\u00a0`.|
+|`helpers-java`|`MFQuotesDecoder`|Decoder for dealing with quotes in MessageFormat strings.|
+|`helpers-java`|`escapesEncoder`|Encoder for escaped chars like `\n`.|
+|`helpers-java`|`MFQuotesEncoder`|Encoder for dealing with quotes in MessageFormat strings.|
+
+###  Java Properties Filter
+
+```js
+this.resourceFilter = new filters.JavaPropertiesFilter();
+```
+
+A filter for properties files used as defined by the Java resource bundle specification.
+
+* [TODO] it needs an option to make it stricter to deal with technically invalid files.

package/filter.js

@@ -0,0 +1,56 @@
+const { parseToEntries, stringifyFromEntries } = require('@js.properties/properties');
+
+module.exports = class JavaPropertiesFilter {
+    async parseResource({ resource }) {
+        const parsedResource = parseToEntries(resource, { sep: true, eol: true, all: true, original: true, location: true });
+        const segments = [];
+        let previousComments = [];
+        for (const e of parsedResource) {
+            if (e.key && e.sep.trim() === '=') {
+                const location = {startLine: e.location.start.line, endLine: e.location.end.line}
+                const seg = {
+                    sid: e.key,
+                    str: e.element,
+                    location
+                };
+
+                if (previousComments.length > 0) {
+                    const notes = previousComments.join('\n');
+                    if (notes.indexOf('DO_NOT_TRANSLATE') === -1) {
+                        segments.push({
+                            ...seg,
+                            notes,
+                        });
+                    }
+                    previousComments = [];
+                } else {
+                    segments.push(seg);
+                }
+            } else {
+                e.original.trim().length > 0 && previousComments.push(e.original);
+            }
+        }
+        return {
+            segments,
+        };
+    }
+
+    async translateResource({ resource, translator }) {
+        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,
+                    })
+                }
+            }
+        }
+        return stringifyFromEntries(translatedEntries);
+    }
+}

package/index.js

@@ -0,0 +1,51 @@
+const { regex } = require('@l10nmonster/helpers');
+
+exports.PropertiesFilter = require('./filter');
+
+const javaControlCharsToDecode = {
+    t: '\t',
+    b: '\b',
+    n: '\n',
+    r: '\r',
+    f: '\f',
+};
+exports.escapesDecoder = regex.decoderMaker(
+    'javaEscapesDecoder',
+    /(?<node>\\(?<escapedChar>['"\\])|\\(?<escapedControl>[tbnrf])|\\u(?<codePoint>[0-9A-Za-z]{4}))/g,
+    (groups) => (groups.escapedChar ??
+        (groups.escapedControl ?
+            (javaControlCharsToDecode[groups.escapedControl] ?? `\\${groups.escapedControl}`) :
+            String.fromCharCode(parseInt(groups.codePoint, 16))
+        )
+    )
+);
+
+// TODO: do we need to escape also those escapedChar that we decoded?
+exports.escapesEncoder = regex.encoderMaker(
+    'javaEscapesEncoder',
+    // eslint-disable-next-line prefer-named-capture-group
+    /(\t)|(\n)|(\r)|(\f)|(\u00a0)/g,
+    {
+        '\t': '\\t',
+        '\n': '\\n',
+        '\r': '\\r',
+        '\f': '\\f',
+        '\u00a0': '\\u00a0',
+    }
+);
+
+exports.MFQuotesDecoder = regex.decoderMaker(
+    'javaMFQuotesDecoder',
+    /(?:(?<quote>')'|(?:'(?<quoted>[^']+)'))/g,
+    groups => groups.quote ?? groups.quoted
+);
+
+// need to be smart about detecting whether MessageFormat was used or not based on presence of {vars}
+exports.MFQuotesEncoder = regex.encoderMaker(
+    'javaMFQuotesEncoder',
+    // eslint-disable-next-line prefer-named-capture-group
+    /(')/g,
+    {
+        "'": "''",
+    }
+);

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@l10nmonster/helpers-java",
+  "version": "1.0.0",
+  "description": "Helpers to deal with Java file formats",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Diego Lagunas",
+  "license": "MIT",
+  "dependencies": {
+    "@js.properties/properties": "^0.5.4"
+  },
+  "peerDependencies": {
+    "@l10nmonster/helpers": "^1"
+  }
+}