@esgettext/tools 1.0.0 → 1.2.0

package/dist/pot/entry.js

@@ -1,10 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.POTEntry = void 0;
-var runtime_1 = require("@esgettext/runtime");
-var gtx = runtime_1.Textdomain.getInstance('tools');
-var POTEntry = (function () {
-    function POTEntry(properties) {
+const runtime_1 = require("@esgettext/runtime");
+const gtx = runtime_1.Textdomain.getInstance('tools');
+/**
+ * Class representing one entry in a POT file. This is simpler than a PO
+ * entry because a couple of things can be ignored:
+ *
+ * - no translations
+ * - no obsolete entries
+ * - no previous translations
+ */
+class POTEntry {
+    /**
+     * Create an entry.
+     *
+     * @param properties - the properties of the entry
+     * @param options - options for wrapping
+     */
+    constructor(properties) {
         this.properties = properties;
         if (/[\u0000-\u0006\u000e-\u001f]/.exec(properties.msgid)) {
             throw new Error(gtx._('msgid must not contain control characters.'));
@@ -24,58 +38,64 @@ var POTEntry = (function () {
                 'Consider adding a message context, if this ' +
                 'is done intentionally.'));
         }
+        // Order matters here. This is most likely the order of appearance
+        // in the source file.
         this.checkDeprecatedControls(this.properties.msgctxt);
         this.checkDeprecatedControls(this.properties.msgid);
         this.checkDeprecatedControls(this.properties.msgidPlural);
+        // See https://savannah.gnu.org/bugs/index.php?58356
         this.checkReferences();
         this.checkFlags();
     }
-    POTEntry.build = function () {
-        var entry = new POTEntry({ msgid: 'ignore' });
-        delete entry.properties.msgid;
+    static build() {
+        const entry = new POTEntry({ msgid: 'ignore' });
+        entry.properties.msgid = undefined;
         return entry;
-    };
-    POTEntry.prototype.toString = function (width) {
-        if (width === void 0) { width = 76; }
-        var out = '';
+    }
+    /**
+     * Serialize the entry to a string that can be put into a POT file.
+     *
+     * (Some) long lines are wrapped to `width` characters. If `width` is
+     * less or equal to zero, lines are not wrapped
+     *
+     * @param width - the requested page width
+     */
+    toString(width = 76) {
+        let out = '';
         if (typeof this.properties.translatorComments !== 'undefined') {
-            for (var _i = 0, _a = this.properties.translatorComments; _i < _a.length; _i++) {
-                var comment = _a[_i];
+            for (let comment of this.properties.translatorComments) {
                 comment = comment.replace(/\n/g, '\n# ');
-                out += "# ".concat(comment, "\n");
+                out += `# ${comment}\n`;
             }
         }
         if (typeof this.properties.extractedComments !== 'undefined') {
-            for (var _b = 0, _c = this.properties.extractedComments; _b < _c.length; _b++) {
-                var comment = _c[_b];
+            for (let comment of this.properties.extractedComments) {
                 comment = comment.replace(/\n/g, '\n#. ');
-                out += "#. ".concat(comment, "\n");
+                out += `#. ${comment}\n`;
             }
         }
         if (typeof this.properties.automatic !== 'undefined') {
-            for (var _d = 0, _e = this.properties.automatic; _d < _e.length; _d++) {
-                var comment = _e[_d];
+            for (let comment of this.properties.automatic) {
                 comment = comment.replace(/\n/g, '\n#. ');
-                out += "#. ".concat(comment, "\n");
+                out += `#. ${comment}\n`;
             }
         }
         if (typeof this.properties.references !== 'undefined') {
-            var references = Array.from(new Set(this.properties.references)).join(' ');
+            const references = Array.from(new Set(this.properties.references)).join(' ');
             if (width > 0) {
-                var wrapped = this.wrap(references, width - 3);
-                for (var _f = 0, wrapped_1 = wrapped; _f < wrapped_1.length; _f++) {
-                    var line = wrapped_1[_f];
-                    out += "#: ".concat(line.trimRight().replace(/ $/, ''), "\n");
+                const wrapped = this.wrap(references, width - 3);
+                for (const line of wrapped) {
+                    out += `#: ${line.trimRight().replace(/ $/, '')}\n`;
                 }
             }
             else {
-                out += "#: ".concat(references, "\n");
+                out += `#: ${references}\n`;
             }
         }
         if (typeof this.properties.flags !== 'undefined' &&
             this.properties.flags.length) {
-            var flags = Array.from(new Set(this.properties.flags)).join(', ');
-            out += "#, ".concat(flags, "\n");
+            const flags = Array.from(new Set(this.properties.flags)).join(', ');
+            out += `#, ${flags}\n`;
         }
         if (typeof this.properties.msgctxt !== 'undefined') {
             out +=
@@ -97,136 +117,178 @@ var POTEntry = (function () {
             out += 'msgstr[0] ""\nmsgstr[1] ""\n';
         }
         return out;
-    };
-    POTEntry.prototype.merge = function (other) {
-        var _a, _b, _c, _d;
-        var _this = this;
+    }
+    /**
+     * Merge to POT entries into one. It is a assumed that both entries share
+     * the same `msgid`, `msgidPlural`, and `msgContext`.
+     *
+     * @param other - the other POT entry
+     */
+    merge(other) {
         if (other.properties.translatorComments) {
             if (!this.properties.translatorComments) {
                 this.properties.translatorComments = new Array();
             }
-            (_a = this.properties.translatorComments).push.apply(_a, other.properties.translatorComments);
+            this.properties.translatorComments.push(...other.properties.translatorComments);
         }
         if (other.properties.automatic) {
             if (!this.properties.automatic) {
                 this.properties.automatic = new Array();
             }
-            (_b = this.properties.automatic).push.apply(_b, other.properties.automatic);
+            this.properties.automatic.push(...other.properties.automatic);
         }
         if (other.properties.flags) {
             if (!this.properties.flags) {
                 this.properties.flags = new Array();
             }
-            other.properties.flags.forEach(function (flag) {
-                var negated = flag.replace(/^no-/, '');
+            other.properties.flags.forEach(flag => {
+                let negated = flag.replace(/^no-/, '');
                 if (negated === flag) {
                     negated = 'no-' + flag;
                 }
-                if (_this.properties.flags.includes(negated)) {
+                if (this.properties.flags.includes(negated)) {
                     other.warning(gtx._x('flag "{flag}" conflicts with previous flag "{negated}"', {
-                        flag: flag,
-                        negated: negated,
+                        flag,
+                        negated,
                     }));
-                    var refs = _this.properties.references;
+                    const refs = this.properties.references;
                     if (refs) {
-                        other.warning(gtx._nx('The conflicting flag "{negated}" may stem from this location:', 'The conflicting flag "{negated}" may stem from one of these locations:', refs.length, { flag: flag, negated: negated }));
-                        refs.forEach(function (ref) {
-                            console.warn("\t".concat(ref));
+                        other.warning(gtx._nx('The conflicting flag "{negated}" may stem from this location:', 'The conflicting flag "{negated}" may stem from one of these locations:', refs.length, { flag, negated }));
+                        refs.forEach(ref => {
+                            console.warn(`\t${ref}`);
                         });
                     }
                 }
             });
-            (_c = this.properties.flags).push.apply(_c, other.properties.flags);
+            this.properties.flags.push(...other.properties.flags);
         }
         if (other.properties.references) {
             if (!this.properties.references) {
                 this.properties.references = new Array();
             }
-            (_d = this.properties.references).push.apply(_d, other.properties.references);
+            this.properties.references.push(...other.properties.references);
         }
-    };
-    POTEntry.prototype.addExtractedCommentLine = function (line) {
+    }
+    /**
+     * Add an extracted comment line.  These are comments starting with "#.".
+     *
+     * @param line - one comment line to add
+     */
+    addExtractedCommentLine(line) {
         if (!this.properties.extractedComments) {
             this.properties.extractedComments = [];
         }
         this.properties.extractedComments.push(line);
-    };
-    POTEntry.prototype.addTranslatorCommentLine = function (line) {
+    }
+    /**
+     * Add a normal comment line.
+     *
+     * @param line - one comment line to add
+     */
+    addTranslatorCommentLine(line) {
         if (!this.properties.translatorComments) {
             this.properties.translatorComments = [];
         }
         this.properties.translatorComments.push(line);
-    };
-    POTEntry.prototype.addFlag = function (flag) {
+    }
+    /**
+     * Add a flag.
+     *
+     * @param flags - the flag to add
+     */
+    addFlag(flag) {
         if (!this.properties.flags) {
             this.properties.flags = [];
         }
         this.properties.flags.push(flag);
-    };
-    POTEntry.prototype.addReference = function (reference) {
+    }
+    /**
+     * Add a reference.
+     *
+     * @param reference - the reference to add
+     */
+    addReference(reference) {
         if (!this.properties.references) {
             this.properties.references = [];
         }
         this.properties.references.push(reference);
-    };
-    POTEntry.prototype.addToMsgid = function (chunk) {
+    }
+    /**
+     * Add a string chunk to the msgid.
+     *
+     * @param chunk - the chunk to add
+     */
+    addToMsgid(chunk) {
         if (typeof this.properties.msgid === 'undefined') {
             this.properties.msgid = '';
         }
         this.properties.msgid += chunk;
-    };
-    POTEntry.prototype.addToMsgidPlural = function (chunk) {
+    }
+    /**
+     * Add a string chunk to the msgid_plural.
+     *
+     * @param chunk - the chunk to add
+     */
+    addToMsgidPlural(chunk) {
         if (typeof this.properties.msgidPlural === 'undefined') {
             this.properties.msgidPlural = '';
         }
         this.properties.msgidPlural += chunk;
-    };
-    POTEntry.prototype.addToMsgstr = function (chunk) {
+    }
+    /**
+     * Add a string chunk to the msgstr.
+     *
+     * @param chunk - the chunk to add
+     */
+    addToMsgstr(chunk) {
         if (typeof this.properties.msgstr === 'undefined') {
             this.properties.msgstr = '';
         }
         this.properties.msgstr += chunk;
-    };
-    POTEntry.prototype.addToMsgctxt = function (chunk) {
+    }
+    /**
+     * Add a string chunk to the msgctxt.
+     *
+     * @param chunk - the chunk to add
+     */
+    addToMsgctxt(chunk) {
         if (typeof this.properties.msgctxt === 'undefined') {
             this.properties.msgctxt = '';
         }
         this.properties.msgctxt += chunk;
-    };
-    POTEntry.prototype.serializeMsgId = function (input, width, prefix) {
-        var _this = this;
-        if (prefix === void 0) { prefix = 'msgid'; }
+    }
+    serializeMsgId(input, width, prefix = 'msgid') {
         if (width <= 0) {
-            var escaped = this.escape(input);
-            return "".concat(prefix, " \"").concat(escaped, "\"");
+            const escaped = this.escape(input);
+            return `${prefix} "${escaped}"`;
         }
-        var output = new Array();
-        var preWrapped = input.split('\n').map(function (str) { return _this.escape(str); });
+        const output = new Array();
+        const preWrapped = input.split('\n').map(str => this.escape(str));
         if (preWrapped.length > 1 ||
             preWrapped[0].length > width - prefix.length - 3) {
-            output.push("".concat(prefix, " \"\""));
+            output.push(`${prefix} ""`);
         }
         else {
-            var chunk = preWrapped.shift();
-            output.push("".concat(prefix, " \"").concat(chunk, "\""));
+            const chunk = preWrapped.shift();
+            output.push(`${prefix} "${chunk}"`);
         }
-        preWrapped.forEach(function (line, index) {
+        preWrapped.forEach((line, index) => {
             if (index < preWrapped.length - 1) {
                 line += '\\n';
             }
             if (line.length) {
-                var wrapped = _this.wrap(line, width - 2);
-                wrapped.forEach(function (inner) {
-                    output.push("\"".concat(inner, "\""));
+                const wrapped = this.wrap(line, width - 2);
+                wrapped.forEach(inner => {
+                    output.push(`"${inner}"`);
                 });
             }
         });
         return output.join('\n');
-    };
-    POTEntry.prototype.wrap = function (input, width) {
-        var output = new Array();
+    }
+    wrap(input, width) {
+        const output = new Array();
         while (input.length > width) {
-            var i = input.lastIndexOf(' ', width);
+            let i = input.lastIndexOf(' ', width);
             if (i < 0) {
                 i = input.indexOf(' ', width);
             }
@@ -238,9 +300,9 @@ var POTEntry = (function () {
         }
         output.push(input);
         return output;
-    };
-    POTEntry.prototype.escape = function (input) {
-        var escapes = {
+    }
+    escape(input) {
+        const escapes = {
             '\u0007': '\\a',
             '\b': '\\b',
             '\t': '\\t',
@@ -251,72 +313,68 @@ var POTEntry = (function () {
             '"': '\\"',
             '\\': '\\\\',
         };
-        return input.replace(/([\u0007-\u000d"\\])/gs, function (m) {
+        return input.replace(/([\u0007-\u000d"\\])/gs, m => {
             return escapes[m[0]];
         });
-    };
-    POTEntry.prototype.checkDeprecatedControls = function (str) {
+    }
+    checkDeprecatedControls(str) {
         if (typeof str === 'undefined') {
             return;
         }
-        var deprecated = RegExp('[\u0007\u0008\u000b-\u000e]', 'gs');
-        var escapes = {
+        const deprecated = RegExp('[\u0007\u0008\u000b-\u000e]', 'gs');
+        const escapes = {
             '\u0007': '\\a',
             '\b': '\\b',
             '\v': '\\v',
             '\f': '\\f',
             '\r': '\\r',
         };
-        var matches;
+        let matches;
         while ((matches = deprecated.exec(str)) !== null) {
-            var escape_1 = escapes[matches[0]];
-            if (!escape_1) {
+            const escape = escapes[matches[0]];
+            if (!escape) {
                 continue;
             }
             delete escapes[matches[0]];
             this.warning(gtx._x('internationalized messages should not ' +
-                "contain the '{escape}' escape sequence", { escape: escape_1 }));
+                "contain the '{escape}' escape sequence", { escape }));
         }
-    };
-    POTEntry.prototype.checkReferences = function () {
-        var _this = this;
+    }
+    checkReferences() {
         if (typeof this.properties.references === 'undefined') {
             return;
         }
-        this.properties.references.forEach(function (ref) {
+        this.properties.references.forEach(ref => {
             if (/[ \n]/.exec(ref)) {
-                _this.error(gtx._('filenames must not contain space or newlines'));
+                this.error(gtx._('filenames must not contain space or newlines'));
             }
         });
-    };
-    POTEntry.prototype.checkFlags = function () {
-        var _this = this;
+    }
+    checkFlags() {
         if (typeof this.properties.flags === 'undefined') {
             return;
         }
-        this.properties.flags.forEach(function (flag) {
+        this.properties.flags.forEach(flag => {
             if (/[,\n]/.exec(flag)) {
-                _this.error(gtx._('flags must not contain commas or newlines'));
+                this.error(gtx._('flags must not contain commas or newlines'));
             }
         });
-    };
-    POTEntry.prototype.error = function (msg) {
-        var location = gtx._('[in memory]');
+    }
+    error(msg) {
+        let location = gtx._('[in memory]');
         if (typeof this.properties.references !== 'undefined') {
             location = this.properties.references[0].toString();
         }
-        throw new Error(gtx._x('{location}: error: {msg}', { location: location, msg: msg }));
-    };
-    POTEntry.prototype.warning = function (msg) {
+        throw new Error(gtx._x('{location}: error: {msg}', { location, msg }));
+    }
+    warning(msg) {
         if (!this.properties.noWarnings) {
-            var location_1 = gtx._('[in memory]');
+            let location = gtx._('[in memory]');
             if (typeof this.properties.references !== 'undefined') {
-                location_1 = this.properties.references[0].toString();
+                location = this.properties.references[0].toString();
             }
-            console.warn(gtx._x('{location}: warning: {msg}', { location: location_1, msg: msg }));
+            console.warn(gtx._x('{location}: warning: {msg}', { location, msg }));
         }
-    };
-    return POTEntry;
-}());
+    }
+}
 exports.POTEntry = POTEntry;
-//# sourceMappingURL=entry.js.map