@worldware/msg-cli 0.2.2 → 0.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +92 -6
- package/dist/{chunk-KKATA5YE.mjs → chunk-DIY2WO3R.mjs} +29 -5
- package/dist/chunk-DPUF7YUH.mjs +269 -0
- package/dist/{chunk-BM3O7ZJW.mjs → chunk-XHD7F45F.mjs} +26 -7
- package/dist/commands/export.cjs +149 -9
- package/dist/commands/export.d.mts +1 -1
- package/dist/commands/export.d.ts +1 -1
- package/dist/commands/export.mjs +4 -3
- package/dist/commands/import.cjs +150 -6
- package/dist/commands/import.d.mts +1 -1
- package/dist/commands/import.d.ts +1 -1
- package/dist/commands/import.mjs +3 -2
- package/dist/lib/export-helpers.cjs +147 -7
- package/dist/lib/export-helpers.d.mts +1 -1
- package/dist/lib/export-helpers.d.ts +1 -1
- package/dist/lib/export-helpers.mjs +2 -1
- package/dist/lib/import-helpers.cjs +149 -5
- package/dist/lib/import-helpers.d.mts +3 -3
- package/dist/lib/import-helpers.d.ts +3 -3
- package/dist/lib/import-helpers.mjs +2 -1
- package/dist/lib/pgs-mf2.cjs +292 -0
- package/dist/lib/pgs-mf2.d.mts +73 -0
- package/dist/lib/pgs-mf2.d.ts +73 -0
- package/dist/lib/pgs-mf2.mjs +18 -0
- package/package.json +3 -2
package/README.md
CHANGED
|
@@ -4,7 +4,7 @@
|
|
|
4
4
|
|
|
5
5
|
msg-cli is a command-line tool for the [msg](https://github.com/worldware-studios/msg) library. It helps you scaffold internationalization (i18n) and localization (l10n) layout and wire up your project for use with msg.
|
|
6
6
|
|
|
7
|
-
**Current status:** CLI for the msg library (npm: `@worldware/msg-cli`, v0.2.2). Commands: `init` (scaffold i18n/l10n and config), `create project` (new MsgProject in i18n/projects), `create resource` (new MsgResource in i18n/resources), `export` (serialize MsgResources to XLIFF 2.
|
|
7
|
+
**Current status:** CLI for the msg library (npm: `@worldware/msg-cli`, v0.2.2). Commands: `init` (scaffold i18n/l10n and config), `create project` (new MsgProject in i18n/projects), `create resource` (new MsgResource in i18n/resources), `export` (serialize MsgResources to XLIFF 2.2 in l10n/xliff), `import` (import translations from XLIFF 2.0/2.2 to JSON in l10n/translations).
|
|
8
8
|
|
|
9
9
|
## Installation
|
|
10
10
|
|
|
@@ -162,7 +162,7 @@ msg create resource myProject messages --edit
|
|
|
162
162
|
|
|
163
163
|
### export
|
|
164
164
|
|
|
165
|
-
Serialize all MsgResource files in `i18n/resources` to XLIFF 2.
|
|
165
|
+
Serialize all MsgResource files in `i18n/resources` to XLIFF 2.2 files in `l10n/xliff`, one file per project. Does not send files for translation; use your own translation workflow with the generated XLIFF. Requires `package.json` with `directories.i18n` and `directories.l10n` (run `msg init` first).
|
|
166
166
|
|
|
167
167
|
```bash
|
|
168
168
|
msg export [-p <projectName>]
|
|
@@ -188,22 +188,24 @@ msg export -p myApp
|
|
|
188
188
|
|
|
189
189
|
- Recursively finds all `.msg.js` and `.msg.ts` files under `i18n/resources`.
|
|
190
190
|
- Imports each file as a MsgResource; errors if any file is invalid.
|
|
191
|
-
- Groups resources by project name and writes one XLIFF 2.
|
|
191
|
+
- Groups resources by project name and writes one XLIFF 2.2 file per project to `l10n/xliff` (e.g. `myApp.xliff`).
|
|
192
192
|
- With `--project`, only that project is exported; existing other files in `l10n/xliff` are not removed.
|
|
193
193
|
- If no MsgResource files are found, exits with an informational message (no error).
|
|
194
194
|
- Logs each major step (finding files, importing, grouping, writing).
|
|
195
195
|
|
|
196
|
-
**What is preserved in XLIFF 2.
|
|
196
|
+
**What is preserved in XLIFF 2.2:**
|
|
197
197
|
|
|
198
198
|
- **Message keys** — Stored as unit `id` (sanitized for XML) and `name` (original key).
|
|
199
199
|
- **Resource notes** — Emitted as file-level `<notes>` with category (e.g. `description`, `comment`).
|
|
200
200
|
- **Resource attributes** — `dir` → file `srcDir`; `dnt` → file `translate="no"`.
|
|
201
201
|
- **Message notes** — Emitted as unit-level `<notes>` with category (e.g. `description`, `context`, `parameters`).
|
|
202
|
-
- **Message attributes** — `dnt` → unit `translate="no"`; message `dir` is serialized as the unit’s `srcDir` attribute (XLIFF
|
|
202
|
+
- **Message attributes** — `dnt` → unit `translate="no"`; message `dir` is serialized as the unit’s `srcDir` attribute (XLIFF text direction for the segment).
|
|
203
|
+
|
|
204
|
+
**Plural, gender, select (PGS) and MessageFormat 2:** Messages written in Unicode MessageFormat 2 using `.match` are exported to the [XLIFF 2.2 Plural, Gender, and Select module](https://docs.oasis-open.org/xliff/xliff-core/v2.2/xliff-extended-v2.2-part2.html) when the selectors classify as `plural`, `ordinal`, `gender`, or `select` (see implementation in `pgs-mf2`). Such units use `xmlns:pgs="urn:oasis:names:tc:xliff:pgs:1.0"`, `pgs:switch` on the `<unit>`, and one `<segment>` per variant with `pgs:case`. Other messages stay a single segment with the full MF2 string in `<source>`. Unsupported `.match` shapes fall back to that single-segment form.
|
|
203
205
|
|
|
204
206
|
### import
|
|
205
207
|
|
|
206
|
-
Import translations from bilingual XLIFF 2.0 files in `l10n/xliff` to JSON files in `l10n/translations`. Expects XLIFF files with `trgLang` (target language) and translated content in `<target>` elements. Writes JSON files without notes for minimal size. Requires `package.json` with `directories.i18n` and `directories.l10n` (run `msg init` first).
|
|
208
|
+
Import translations from bilingual XLIFF 2.0 or 2.2 files in `l10n/xliff` to JSON files in `l10n/translations`. Expects XLIFF files with `trgLang` (target language) and translated content in `<target>` elements. Writes JSON files without notes for minimal size. Requires `package.json` with `directories.i18n` and `directories.l10n` (run `msg init` first). Units with `pgs:switch` are reassembled into a single MessageFormat 2 string per message key from the segment bodies (targets when present).
|
|
207
209
|
|
|
208
210
|
```bash
|
|
209
211
|
msg import [-p <projectName>] [-l <locale>]
|
|
@@ -242,6 +244,90 @@ msg import -l zh
|
|
|
242
244
|
- Preserves existing translation files for other projects or locales when filtering.
|
|
243
245
|
- Errors on malformed XLIFF and logs each step.
|
|
244
246
|
|
|
247
|
+
### Example: plural messages (XLIFF 2.2 PGS)
|
|
248
|
+
|
|
249
|
+
Plural (and other classifiable `.match`) messages use the [XLIFF 2.2 PGS module](https://docs.oasis-open.org/xliff/xliff-core/v2.2/xliff-extended-v2.2-part2.html): export splits them into one `<segment>` per variant (`pgs:case`), and import merges `<target>` text back into a single MessageFormat 2 string per message key.
|
|
250
|
+
|
|
251
|
+
**1. Message in the MsgResource** (Unicode MessageFormat 2 with `.input` / `.match` on a plural):
|
|
252
|
+
|
|
253
|
+
```js
|
|
254
|
+
// i18n/resources/messages.msg.js — excerpt
|
|
255
|
+
itemsCount: `.input {$n :number}
|
|
256
|
+
.match $n
|
|
257
|
+
one {{One item}}
|
|
258
|
+
* {{{$n} items}}`,
|
|
259
|
+
```
|
|
260
|
+
|
|
261
|
+
**2. Export** — writes monolingual XLIFF 2.2 to `l10n/xliff/<project>.xliff` (here `l10n/xliff/myApp.xliff`):
|
|
262
|
+
|
|
263
|
+
```bash
|
|
264
|
+
msg export
|
|
265
|
+
# or: msg export --project myApp
|
|
266
|
+
```
|
|
267
|
+
|
|
268
|
+
The plural becomes a `pgs:switch` unit with one segment per case (abbreviated):
|
|
269
|
+
|
|
270
|
+
```xml
|
|
271
|
+
<?xml version="1.0" encoding="UTF-8"?>
|
|
272
|
+
<xliff xmlns="urn:oasis:names:tc:xliff:document:2.2" xmlns:pgs="urn:oasis:names:tc:xliff:pgs:1.0" version="2.2" srcLang="en">
|
|
273
|
+
<file id="f1" original="messages.json" srcDir="ltr">
|
|
274
|
+
<unit id="itemsCount" name="itemsCount" pgs:switch="plural:n">
|
|
275
|
+
<segment id="itemsCount_s1" pgs:case="one">
|
|
276
|
+
<source>One item</source>
|
|
277
|
+
</segment>
|
|
278
|
+
<segment id="itemsCount_s2" pgs:case="other">
|
|
279
|
+
<source>{$n} items</source>
|
|
280
|
+
</segment>
|
|
281
|
+
</unit>
|
|
282
|
+
</file>
|
|
283
|
+
</xliff>
|
|
284
|
+
```
|
|
285
|
+
|
|
286
|
+
**3. Bilingual file for translation** — `msg import` needs `trgLang` and `<target>` elements. Typical workflow: copy the export to a locale-specific name such as `myApp.fr.xliff`, set `trgLang="fr"` on the root `<xliff>`, and add a `<target>` under **each** `<segment>` (preserving `pgs:switch` / `pgs:case`). The project’s `MsgProject` must list `fr` in `targetLocales`.
|
|
287
|
+
|
|
288
|
+
```xml
|
|
289
|
+
<xliff xmlns="urn:oasis:names:tc:xliff:document:2.2" xmlns:pgs="urn:oasis:names:tc:xliff:pgs:1.0" version="2.2" srcLang="en" trgLang="fr">
|
|
290
|
+
<file id="f1" original="messages.json" srcDir="ltr">
|
|
291
|
+
<unit id="itemsCount" name="itemsCount" pgs:switch="plural:n">
|
|
292
|
+
<segment id="itemsCount_s1" pgs:case="one">
|
|
293
|
+
<source>One item</source>
|
|
294
|
+
<target>Un élément</target>
|
|
295
|
+
</segment>
|
|
296
|
+
<segment id="itemsCount_s2" pgs:case="other">
|
|
297
|
+
<source>{$n} items</source>
|
|
298
|
+
<target>{$n} éléments</target>
|
|
299
|
+
</segment>
|
|
300
|
+
</unit>
|
|
301
|
+
</file>
|
|
302
|
+
</xliff>
|
|
303
|
+
```
|
|
304
|
+
|
|
305
|
+
**4. Import** — writes minimal JSON under `l10n/translations/<project>/<locale>/<resource>.json`, with one MF2 message per key rebuilt from the PGS segments:
|
|
306
|
+
|
|
307
|
+
```bash
|
|
308
|
+
msg import
|
|
309
|
+
# or: msg import --project myApp --language fr
|
|
310
|
+
```
|
|
311
|
+
|
|
312
|
+
**5. Resulting French translation file** — `l10n/translations/myApp/fr/messages.json` (notes omitted; `attributes.dir` is empty unless the XLIFF `<file>` carries `trgDir`):
|
|
313
|
+
|
|
314
|
+
```json
|
|
315
|
+
{
|
|
316
|
+
"title": "messages",
|
|
317
|
+
"attributes": {
|
|
318
|
+
"lang": "fr",
|
|
319
|
+
"dir": "",
|
|
320
|
+
"dnt": false
|
|
321
|
+
},
|
|
322
|
+
"messages": [
|
|
323
|
+
{
|
|
324
|
+
"key": "itemsCount",
|
|
325
|
+
"value": ".input {$n :number}\n.match $n\none {{Un élément}}\n* {{{$n} éléments}}"
|
|
326
|
+
}
|
|
327
|
+
]
|
|
328
|
+
}
|
|
329
|
+
```
|
|
330
|
+
|
|
245
331
|
## API Reference
|
|
246
332
|
|
|
247
333
|
The CLI does not expose a programmatic API. For library usage, see [@worldware/msg](https://github.com/worldware-studios/msg).
|
|
@@ -1,3 +1,6 @@
|
|
|
1
|
+
import {
|
|
2
|
+
pgsImportToSelectMessage
|
|
3
|
+
} from "./chunk-DPUF7YUH.mjs";
|
|
1
4
|
import {
|
|
2
5
|
dynamicImportFromUrl
|
|
3
6
|
} from "./chunk-LNCUPVEF.mjs";
|
|
@@ -110,7 +113,7 @@ function parseXliff20(xml) {
|
|
|
110
113
|
return parsed;
|
|
111
114
|
} catch (err) {
|
|
112
115
|
const message = err instanceof Error ? err.message : "Failed to parse XLIFF";
|
|
113
|
-
throw new Error(`Malformed XLIFF
|
|
116
|
+
throw new Error(`Malformed XLIFF: ${message}`);
|
|
114
117
|
}
|
|
115
118
|
}
|
|
116
119
|
function categoryToNoteType(category) {
|
|
@@ -197,11 +200,32 @@ function processUnit(unit, fileAttrs) {
|
|
|
197
200
|
}
|
|
198
201
|
}
|
|
199
202
|
const segments = unit.segment ? Array.isArray(unit.segment) ? unit.segment : [unit.segment] : [];
|
|
200
|
-
const
|
|
201
|
-
|
|
202
|
-
|
|
203
|
+
const pgsSwitch = unit["@_pgs:switch"];
|
|
204
|
+
let value;
|
|
205
|
+
if (pgsSwitch && segments.length > 0 && segments.every(
|
|
206
|
+
(seg) => typeof seg["@_pgs:case"] === "string"
|
|
207
|
+
)) {
|
|
208
|
+
const importSegments = segments.map((seg) => ({
|
|
209
|
+
caseAttr: seg["@_pgs:case"],
|
|
210
|
+
body: extractSegmentText(seg)
|
|
211
|
+
}));
|
|
212
|
+
const rebuilt = pgsImportToSelectMessage(pgsSwitch, importSegments);
|
|
213
|
+
if (rebuilt) {
|
|
214
|
+
value = rebuilt;
|
|
215
|
+
} else {
|
|
216
|
+
const targetParts = [];
|
|
217
|
+
for (const seg of segments) {
|
|
218
|
+
targetParts.push(extractSegmentText(seg));
|
|
219
|
+
}
|
|
220
|
+
value = targetParts.join("");
|
|
221
|
+
}
|
|
222
|
+
} else {
|
|
223
|
+
const targetParts = [];
|
|
224
|
+
for (const seg of segments) {
|
|
225
|
+
targetParts.push(extractSegmentText(seg));
|
|
226
|
+
}
|
|
227
|
+
value = targetParts.join("");
|
|
203
228
|
}
|
|
204
|
-
const value = targetParts.join("");
|
|
205
229
|
const attributes = {};
|
|
206
230
|
if (trgLang !== fileAttrs.trgLang) attributes.lang = trgLang || void 0;
|
|
207
231
|
if (trgDir !== fileAttrs.trgDir) attributes.dir = trgDir || void 0;
|
|
@@ -0,0 +1,269 @@
|
|
|
1
|
+
// src/lib/pgs-mf2.ts
|
|
2
|
+
import {
|
|
3
|
+
parseMessage,
|
|
4
|
+
stringifyMessage,
|
|
5
|
+
validate,
|
|
6
|
+
isSelectMessage,
|
|
7
|
+
isCatchallKey,
|
|
8
|
+
isLiteral
|
|
9
|
+
} from "messageformat";
|
|
10
|
+
var PGS_SWITCH_ITEM = /^(plural|ordinal|gender|select):([a-zA-Z_][a-zA-Z0-9_]*)$/;
|
|
11
|
+
var GENDER_LABELS = /* @__PURE__ */ new Set([
|
|
12
|
+
"feminine",
|
|
13
|
+
"masculine",
|
|
14
|
+
"neuter",
|
|
15
|
+
"other"
|
|
16
|
+
]);
|
|
17
|
+
function parsePgsSwitch(value) {
|
|
18
|
+
const trimmed = value.trim();
|
|
19
|
+
if (!trimmed) return null;
|
|
20
|
+
const parts = trimmed.split(/\s+/);
|
|
21
|
+
const out = [];
|
|
22
|
+
for (const p of parts) {
|
|
23
|
+
const m = p.match(PGS_SWITCH_ITEM);
|
|
24
|
+
if (!m) return null;
|
|
25
|
+
out.push({ kind: m[1], name: m[2] });
|
|
26
|
+
}
|
|
27
|
+
return out.length > 0 ? out : null;
|
|
28
|
+
}
|
|
29
|
+
function findInputDeclaration(msg, varName) {
|
|
30
|
+
for (const d of msg.declarations) {
|
|
31
|
+
const decl = d;
|
|
32
|
+
if (decl.type === "input" && decl.name === varName) {
|
|
33
|
+
return decl;
|
|
34
|
+
}
|
|
35
|
+
}
|
|
36
|
+
return null;
|
|
37
|
+
}
|
|
38
|
+
function getFunctionName(expr) {
|
|
39
|
+
return expr.functionRef?.name;
|
|
40
|
+
}
|
|
41
|
+
function getSelectOptionOrdinal(expr) {
|
|
42
|
+
const opts = expr.functionRef?.options;
|
|
43
|
+
if (!opts || !(opts instanceof Map)) return false;
|
|
44
|
+
const sel = opts.get("select");
|
|
45
|
+
if (!sel || typeof sel !== "object" || sel === null) return false;
|
|
46
|
+
if (sel.type !== "literal") return false;
|
|
47
|
+
return sel.value === "ordinal";
|
|
48
|
+
}
|
|
49
|
+
function variantKeyAt(msg, variantIndex, keyIndex) {
|
|
50
|
+
const v = msg.variants[variantIndex];
|
|
51
|
+
return v?.keys[keyIndex];
|
|
52
|
+
}
|
|
53
|
+
function allKeysAtIndexAreGenderLike(msg, keyIndex) {
|
|
54
|
+
for (let vi = 0; vi < msg.variants.length; vi++) {
|
|
55
|
+
const k = variantKeyAt(msg, vi, keyIndex);
|
|
56
|
+
if (!k) return false;
|
|
57
|
+
if (isCatchallKey(k)) continue;
|
|
58
|
+
if (isLiteral(k)) {
|
|
59
|
+
if (!GENDER_LABELS.has(k.value)) return false;
|
|
60
|
+
continue;
|
|
61
|
+
}
|
|
62
|
+
return false;
|
|
63
|
+
}
|
|
64
|
+
return true;
|
|
65
|
+
}
|
|
66
|
+
function classifySelectMessageForPgs(msg) {
|
|
67
|
+
const out = [];
|
|
68
|
+
for (let si = 0; si < msg.selectors.length; si++) {
|
|
69
|
+
const sel = msg.selectors[si];
|
|
70
|
+
if (!sel || sel.type !== "variable" || !sel.name) return null;
|
|
71
|
+
const varName = sel.name;
|
|
72
|
+
const decl = findInputDeclaration(msg, varName);
|
|
73
|
+
if (!decl) return null;
|
|
74
|
+
const expr = decl.value;
|
|
75
|
+
if (expr.type !== "expression") return null;
|
|
76
|
+
const fname = getFunctionName(expr);
|
|
77
|
+
if (fname === "number") {
|
|
78
|
+
out.push({
|
|
79
|
+
kind: getSelectOptionOrdinal(expr) ? "ordinal" : "plural",
|
|
80
|
+
name: varName
|
|
81
|
+
});
|
|
82
|
+
continue;
|
|
83
|
+
}
|
|
84
|
+
if (fname === "string") {
|
|
85
|
+
const kind = allKeysAtIndexAreGenderLike(msg, si) ? "gender" : "select";
|
|
86
|
+
out.push({ kind, name: varName });
|
|
87
|
+
continue;
|
|
88
|
+
}
|
|
89
|
+
return null;
|
|
90
|
+
}
|
|
91
|
+
return out.length === msg.selectors.length ? out : null;
|
|
92
|
+
}
|
|
93
|
+
function mf2KeyToPgsToken(key, kind) {
|
|
94
|
+
if (isCatchallKey(key)) {
|
|
95
|
+
return "other";
|
|
96
|
+
}
|
|
97
|
+
if (isLiteral(key)) {
|
|
98
|
+
return key.value;
|
|
99
|
+
}
|
|
100
|
+
return "other";
|
|
101
|
+
}
|
|
102
|
+
function pgsTokenToMf2Key(token, kind) {
|
|
103
|
+
if (kind === "plural" || kind === "ordinal") {
|
|
104
|
+
if (token === "other") {
|
|
105
|
+
return { type: "*" };
|
|
106
|
+
}
|
|
107
|
+
return { type: "literal", value: token };
|
|
108
|
+
}
|
|
109
|
+
return { type: "literal", value: token };
|
|
110
|
+
}
|
|
111
|
+
function stringifyPattern(pattern) {
|
|
112
|
+
const wrap = {
|
|
113
|
+
type: "message",
|
|
114
|
+
declarations: [],
|
|
115
|
+
pattern
|
|
116
|
+
};
|
|
117
|
+
return stringifyMessage(
|
|
118
|
+
wrap
|
|
119
|
+
);
|
|
120
|
+
}
|
|
121
|
+
function selectMessageToPgsExport(source) {
|
|
122
|
+
let msg;
|
|
123
|
+
try {
|
|
124
|
+
msg = parseMessage(source);
|
|
125
|
+
} catch {
|
|
126
|
+
return null;
|
|
127
|
+
}
|
|
128
|
+
if (!isSelectMessage(msg)) return null;
|
|
129
|
+
const classification = classifySelectMessageForPgs(
|
|
130
|
+
msg
|
|
131
|
+
);
|
|
132
|
+
if (!classification) return null;
|
|
133
|
+
const switchAttr = classification.map((c) => `${c.kind}:${c.name}`).join(" ");
|
|
134
|
+
const segments = [];
|
|
135
|
+
const sel = msg;
|
|
136
|
+
for (let vi = 0; vi < sel.variants.length; vi++) {
|
|
137
|
+
const variant = sel.variants[vi];
|
|
138
|
+
const caseParts = [];
|
|
139
|
+
for (let ki = 0; ki < classification.length; ki++) {
|
|
140
|
+
const key = variant.keys[ki];
|
|
141
|
+
if (!key) return null;
|
|
142
|
+
caseParts.push(
|
|
143
|
+
mf2KeyToPgsToken(key, classification[ki].kind)
|
|
144
|
+
);
|
|
145
|
+
}
|
|
146
|
+
segments.push({
|
|
147
|
+
caseAttr: caseParts.join(" "),
|
|
148
|
+
sourcePattern: stringifyPattern(variant.value)
|
|
149
|
+
});
|
|
150
|
+
}
|
|
151
|
+
return { switchAttr, segments };
|
|
152
|
+
}
|
|
153
|
+
function parsePatternFromSegmentBody(body) {
|
|
154
|
+
const trimmed = body.trim();
|
|
155
|
+
if (!trimmed) return [];
|
|
156
|
+
try {
|
|
157
|
+
const m = parseMessage(trimmed);
|
|
158
|
+
if (m.type !== "message") return [];
|
|
159
|
+
return m.pattern;
|
|
160
|
+
} catch {
|
|
161
|
+
return [];
|
|
162
|
+
}
|
|
163
|
+
}
|
|
164
|
+
function ensureFallbackVariant(keysCount, variants) {
|
|
165
|
+
const hasAllStars = variants.some(
|
|
166
|
+
(v) => v.keys.length === keysCount && v.keys.every((k) => isCatchallKey(k))
|
|
167
|
+
);
|
|
168
|
+
if (hasAllStars) return;
|
|
169
|
+
const fallbackPattern = variants.length > 0 ? variants[variants.length - 1].value : [];
|
|
170
|
+
const starKeys = Array.from({ length: keysCount }, () => ({
|
|
171
|
+
type: "*"
|
|
172
|
+
}));
|
|
173
|
+
variants.push({ keys: starKeys, value: fallbackPattern });
|
|
174
|
+
}
|
|
175
|
+
function pgsImportToSelectMessage(switchAttr, segments) {
|
|
176
|
+
const parsedSwitch = parsePgsSwitch(switchAttr);
|
|
177
|
+
if (!parsedSwitch || parsedSwitch.length === 0) return null;
|
|
178
|
+
const n = parsedSwitch.length;
|
|
179
|
+
const declarations = [];
|
|
180
|
+
for (const { kind, name } of parsedSwitch) {
|
|
181
|
+
const varRef = { type: "variable", name };
|
|
182
|
+
if (kind === "plural") {
|
|
183
|
+
declarations.push({
|
|
184
|
+
type: "input",
|
|
185
|
+
name,
|
|
186
|
+
value: {
|
|
187
|
+
type: "expression",
|
|
188
|
+
arg: varRef,
|
|
189
|
+
functionRef: { type: "function", name: "number" }
|
|
190
|
+
}
|
|
191
|
+
});
|
|
192
|
+
} else if (kind === "ordinal") {
|
|
193
|
+
const opts = /* @__PURE__ */ new Map([
|
|
194
|
+
["select", { type: "literal", value: "ordinal" }]
|
|
195
|
+
]);
|
|
196
|
+
declarations.push({
|
|
197
|
+
type: "input",
|
|
198
|
+
name,
|
|
199
|
+
value: {
|
|
200
|
+
type: "expression",
|
|
201
|
+
arg: varRef,
|
|
202
|
+
functionRef: { type: "function", name: "number", options: opts }
|
|
203
|
+
}
|
|
204
|
+
});
|
|
205
|
+
} else {
|
|
206
|
+
declarations.push({
|
|
207
|
+
type: "input",
|
|
208
|
+
name,
|
|
209
|
+
value: {
|
|
210
|
+
type: "expression",
|
|
211
|
+
arg: varRef,
|
|
212
|
+
functionRef: { type: "function", name: "string" }
|
|
213
|
+
}
|
|
214
|
+
});
|
|
215
|
+
}
|
|
216
|
+
}
|
|
217
|
+
const selectors = parsedSwitch.map(
|
|
218
|
+
({ name }) => ({ type: "variable", name })
|
|
219
|
+
);
|
|
220
|
+
const variants = [];
|
|
221
|
+
for (const seg of segments) {
|
|
222
|
+
const tokens = seg.caseAttr.trim().split(/\s+/).filter(Boolean);
|
|
223
|
+
if (tokens.length !== n) return null;
|
|
224
|
+
const keys = tokens.map(
|
|
225
|
+
(t, i) => pgsTokenToMf2Key(t, parsedSwitch[i].kind)
|
|
226
|
+
);
|
|
227
|
+
variants.push({
|
|
228
|
+
keys,
|
|
229
|
+
value: parsePatternFromSegmentBody(seg.body)
|
|
230
|
+
});
|
|
231
|
+
}
|
|
232
|
+
if (variants.length === 0) return null;
|
|
233
|
+
const msg = {
|
|
234
|
+
type: "select",
|
|
235
|
+
declarations,
|
|
236
|
+
selectors,
|
|
237
|
+
variants
|
|
238
|
+
};
|
|
239
|
+
ensureFallbackVariant(n, msg.variants);
|
|
240
|
+
try {
|
|
241
|
+
validate(
|
|
242
|
+
msg
|
|
243
|
+
);
|
|
244
|
+
} catch {
|
|
245
|
+
return null;
|
|
246
|
+
}
|
|
247
|
+
return stringifyMessage(
|
|
248
|
+
msg
|
|
249
|
+
);
|
|
250
|
+
}
|
|
251
|
+
function messagesStructurallyEqual(a, b) {
|
|
252
|
+
try {
|
|
253
|
+
const ma = parseMessage(a);
|
|
254
|
+
const mb = parseMessage(b);
|
|
255
|
+
return stringifyMessage(ma) === stringifyMessage(mb);
|
|
256
|
+
} catch {
|
|
257
|
+
return false;
|
|
258
|
+
}
|
|
259
|
+
}
|
|
260
|
+
|
|
261
|
+
export {
|
|
262
|
+
parsePgsSwitch,
|
|
263
|
+
classifySelectMessageForPgs,
|
|
264
|
+
mf2KeyToPgsToken,
|
|
265
|
+
pgsTokenToMf2Key,
|
|
266
|
+
selectMessageToPgsExport,
|
|
267
|
+
pgsImportToSelectMessage,
|
|
268
|
+
messagesStructurallyEqual
|
|
269
|
+
};
|
|
@@ -1,3 +1,6 @@
|
|
|
1
|
+
import {
|
|
2
|
+
selectMessageToPgsExport
|
|
3
|
+
} from "./chunk-DPUF7YUH.mjs";
|
|
1
4
|
import {
|
|
2
5
|
dynamicImportFromUrl
|
|
3
6
|
} from "./chunk-LNCUPVEF.mjs";
|
|
@@ -10,7 +13,8 @@ var MSG_PATTERN = /\.msg\.(ts|js)$/i;
|
|
|
10
13
|
function isMsgResourceLike(value) {
|
|
11
14
|
return Boolean(value) && typeof value.getProject === "function";
|
|
12
15
|
}
|
|
13
|
-
var
|
|
16
|
+
var XLIFF22_NS = "urn:oasis:names:tc:xliff:document:2.2";
|
|
17
|
+
var PGS_NS = "urn:oasis:names:tc:xliff:pgs:1.0";
|
|
14
18
|
async function findMsgResourceFilePaths(directory) {
|
|
15
19
|
const result = [];
|
|
16
20
|
const entries = await readdir(directory, { withFileTypes: true });
|
|
@@ -93,11 +97,11 @@ function renderNotes(notes, idPrefix, indent = " ") {
|
|
|
93
97
|
parts.push(`${indent}</notes>`);
|
|
94
98
|
return parts;
|
|
95
99
|
}
|
|
96
|
-
function
|
|
100
|
+
function resourceGroupToXliff22(group) {
|
|
97
101
|
const srcLang = group.resources[0]?.attributes?.lang ?? "en";
|
|
98
102
|
const parts = [
|
|
99
103
|
'<?xml version="1.0" encoding="UTF-8"?>',
|
|
100
|
-
`<xliff xmlns="${
|
|
104
|
+
`<xliff xmlns="${XLIFF22_NS}" xmlns:pgs="${PGS_NS}" version="2.2" srcLang="${escapeXml(srcLang)}">`
|
|
101
105
|
];
|
|
102
106
|
let fileIndex = 0;
|
|
103
107
|
for (const resource of group.resources) {
|
|
@@ -135,6 +139,10 @@ function resourceGroupToXliff20(group) {
|
|
|
135
139
|
if (msgAttr?.dir) {
|
|
136
140
|
msgAttrs.push(`srcDir="${escapeXml(msgAttr.dir)}"`);
|
|
137
141
|
}
|
|
142
|
+
const pgsExport = selectMessageToPgsExport(msg.value);
|
|
143
|
+
if (pgsExport) {
|
|
144
|
+
msgAttrs.push(`pgs:switch="${escapeXml(pgsExport.switchAttr)}"`);
|
|
145
|
+
}
|
|
138
146
|
parts.push(` <unit ${msgAttrs.join(" ")}>`);
|
|
139
147
|
const msgNotes = msg.notes ?? [];
|
|
140
148
|
if (msgNotes.length > 0) {
|
|
@@ -142,9 +150,20 @@ function resourceGroupToXliff20(group) {
|
|
|
142
150
|
...renderNotes(msgNotes, `${fileId}-${unitId}`, " ")
|
|
143
151
|
);
|
|
144
152
|
}
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
153
|
+
if (pgsExport) {
|
|
154
|
+
pgsExport.segments.forEach((seg, segIdx) => {
|
|
155
|
+
const segId = `${unitId}_s${segIdx + 1}`;
|
|
156
|
+
parts.push(
|
|
157
|
+
` <segment id="${escapeXml(segId)}" pgs:case="${escapeXml(seg.caseAttr)}">`
|
|
158
|
+
);
|
|
159
|
+
parts.push(` <source>${escapeXml(seg.sourcePattern)}</source>`);
|
|
160
|
+
parts.push(" </segment>");
|
|
161
|
+
});
|
|
162
|
+
} else {
|
|
163
|
+
parts.push(" <segment>");
|
|
164
|
+
parts.push(` <source>${escapeXml(msg.value)}</source>`);
|
|
165
|
+
parts.push(" </segment>");
|
|
166
|
+
}
|
|
148
167
|
parts.push(" </unit>");
|
|
149
168
|
});
|
|
150
169
|
parts.push(" </file>");
|
|
@@ -155,7 +174,7 @@ function resourceGroupToXliff20(group) {
|
|
|
155
174
|
function serializeResourceGroupsToXliff(groups) {
|
|
156
175
|
return groups.map((group) => ({
|
|
157
176
|
project: group.project,
|
|
158
|
-
xliff:
|
|
177
|
+
xliff: resourceGroupToXliff22(group)
|
|
159
178
|
}));
|
|
160
179
|
}
|
|
161
180
|
async function writeXliffFiles(xliffDir, xliffGroups) {
|