First iteration on supporting po, xliff and csv/tsv format for translation files

Author: jeremyfa

cpp/include/Loreline.h

@@ -284,6 +284,20 @@ LORELINE_PUBLIC void Loreline_loadLocaleAsync(
     void* completionHandlerData
 );
 
+/* Enable or disable runtime support for an alternate translation file format.
+ *
+ * By default, only `.<locale>.lor` files are tried by Loreline_loadLocale.
+ * Call this to opt in to additional formats:
+ *   - "po"    — GNU gettext PO (.po)
+ *   - "xliff" — XLIFF 1.2 / 2.x (.xliff, .xlf)
+ *   - "csv"   — CSV / TSV (.csv, .tsv)
+ *
+ * Unknown names are accepted silently (forward-compat). */
+LORELINE_PUBLIC void Loreline_translationFormat(
+    Loreline_String name,
+    bool enabled
+);
+
 /* Interpreter options — configure custom functions, strict access, translations */
 LORELINE_PUBLIC Loreline_InterpreterOptions* Loreline_createOptions(void);
 LORELINE_PUBLIC void Loreline_releaseOptions(Loreline_InterpreterOptions* options);

godot/src/loreline_js_bridge.h

@@ -174,6 +174,13 @@ static const char LORELINE_JS_BRIDGE[] = R"LORELINE_BRIDGE(
             _releaseObj(translationsId);
         },
 
+        // --- Translation formats (PO, XLIFF, CSV...) ---
+        // Enable/disable runtime support for an alternate translation file format.
+        // Names: "po", "xliff", "csv". Unknown names accepted silently.
+        translationFormat: function(name, enabled) {
+            Loreline.translationFormat(name, enabled);
+        },
+
         provideFunctionDone: function(callId) {
             var entry = _pendingFunctionDone[callId];
             if (entry) {

godot/src/loreline_runtime.cpp

@@ -74,6 +74,7 @@ void Loreline::_bind_methods() {
 	ClassDB::bind_static_method("Loreline", D_METHOD("shared"), &Loreline::shared);
 	ClassDB::bind_method(D_METHOD("parse", "source", "file_path", "file_handler"), &Loreline::parse, DEFVAL(""), DEFVAL(Callable()));
 	ClassDB::bind_method(D_METHOD("load_locale", "locale", "script", "file_path", "file_handler"), &Loreline::load_locale, DEFVAL(""), DEFVAL(Callable()));
+	ClassDB::bind_method(D_METHOD("translation_format", "name", "enabled"), &Loreline::translation_format);
 	ClassDB::bind_method(D_METHOD("play", "script", "on_dialogue", "on_choice", "on_finished", "beat_name", "options"), &Loreline::play, DEFVAL(Callable()), DEFVAL(Callable()), DEFVAL(Callable()), DEFVAL(""), DEFVAL(Ref<LorelineOptions>()));
 	ClassDB::bind_method(D_METHOD("resume", "script", "on_dialogue", "on_choice", "on_finished", "save_data", "beat_name", "options"), &Loreline::resume, DEFVAL(""), DEFVAL(Ref<LorelineOptions>()));
 }
@@ -545,6 +546,19 @@ Signal Loreline::load_locale(const String &locale, const Ref<LorelineScript> &sc
 #endif
 }
 
+void Loreline::translation_format(const String &name, bool enabled) {
+#ifdef LORELINE_USE_JS
+	JavaScriptBridge *js = JavaScriptBridge::get_singleton();
+	if (!js) return;
+	String escaped = loreline_escape_js(name);
+	String js_code = String("_lorelineBridge.translationFormat('") + escaped + "'," + (enabled ? "true" : "false") + ")";
+	js->eval(js_code, true);
+#else
+	CharString name_utf8 = name.utf8();
+	Loreline_translationFormat(Loreline_String(name_utf8.get_data()), enabled);
+#endif
+}
+
 Ref<LorelineInterpreter> Loreline::play(const Ref<LorelineScript> &script, const Callable &on_dialogue, const Callable &on_choice, const Callable &on_finished, const String &beat_name, const Ref<LorelineOptions> &options) {
 	if (!_initialized) {
 		UtilityFunctions::push_error("Loreline: not initialized. Add this node to the scene tree first.");

godot/src/loreline_runtime.h

@@ -124,6 +124,11 @@ class Loreline : public Node {
 	//   var translations = await loreline.load_locale("fr", script)
 	Signal load_locale(const String &locale, const Ref<LorelineScript> &script, const String &file_path = "", const Callable &file_handler = Callable());
 
+	// Enable or disable runtime support for an alternate translation file
+	// format. By default only `.<locale>.lor` is tried.
+	// Known names: "po", "xliff", "csv". Unknown names accepted silently.
+	void translation_format(const String &name, bool enabled);
+
 	Ref<LorelineInterpreter> play(const Ref<LorelineScript> &script, const Callable &on_dialogue = Callable(), const Callable &on_choice = Callable(), const Callable &on_finished = Callable(), const String &beat_name = "", const Ref<LorelineOptions> &options = Ref<LorelineOptions>());
 	Ref<LorelineInterpreter> resume(const Ref<LorelineScript> &script, const Callable &on_dialogue, const Callable &on_choice, const Callable &on_finished, const String &save_data, const String &beat_name = "", const Ref<LorelineOptions> &options = Ref<LorelineOptions>());
 

js/loreline.d.ts

@@ -297,6 +297,22 @@ export class Loreline {
         callback?: (translations: Translations) => void
     ): Translations | null;
 
+    /**
+     * Enable or disable runtime support for an alternate translation file format.
+     *
+     * By default only `.<locale>.lor` files are tried by `loadLocale`. Call
+     * this to opt in to additional formats:
+     * - `"po"`    — GNU gettext PO (`.po`)
+     * - `"xliff"` — XLIFF 1.2 / 2.x (`.xliff`, `.xlf`)
+     * - `"csv"`   — CSV / TSV (`.csv`, `.tsv`)
+     *
+     * Unknown names are accepted silently (forward-compat for future formats).
+     *
+     * @param name The format identifier (see above)
+     * @param enabled True to enable the format, false to disable
+     */
+    static translationFormat(name: string, enabled: boolean): void;
+
     /**
      * Prints a parsed script back into Loreline source code.
      *

js/test-runner.ts

@@ -289,6 +289,11 @@ async function main(): Promise<void> {
         process.exit(1);
     }
 
+    // Test fixtures exercise every supported translation format.
+    Loreline.translationFormat('po', true);
+    Loreline.translationFormat('xliff', true);
+    Loreline.translationFormat('csv', true);
+
     for (const filePath of testFiles) {
         const rawContent: string = readFileSync(filePath, 'utf-8');
         const testItems: TestItem[] = extractTests(rawContent);

jvm/src/loreline/Loreline.java

@@ -124,6 +124,21 @@ public static Object extractTranslations(Script script) {
         return loreline.runtime.Loreline.extractTranslations(script.runtimeScript);
     }
 
+    /**
+     * Enable or disable runtime support for an alternate translation file format.
+     *
+     * By default only `.<locale>.lor` files are tried by loadLocale. Call this
+     * to opt in to additional formats. Known names:
+     *   - "po"    — GNU gettext PO (.po)
+     *   - "xliff" — XLIFF 1.2 / 2.x (.xliff, .xlf)
+     *   - "csv"   — CSV / TSV (.csv, .tsv)
+     *
+     * Unknown names are accepted silently (forward-compat).
+     */
+    public static void translationFormat(String name, boolean enabled) {
+        loreline.runtime.Loreline.translationFormat(name, enabled);
+    }
+
     /**
      * Loads translations for a specific locale.
      * Walks the script's full import tree and loads `.<locale>.lor` files for each.

src/loreline/Loreline.hx

@@ -140,12 +140,24 @@ class Loreline {
             throw new Error("Cannot load locale: handleFile is required");
         }
 
-        // Determine which Loreline extension we're working with: prefer the source script's
-        // extension when known, otherwise infer from filePath. The result is the canonical
-        // lowercase ".lor" or ".lor.txt" used to build translation file names.
-        final ext = (script.filePath != null && Imports.endsWithLorTxt(script.filePath))
-            ? '.lor.txt'
-            : Imports.lorExtension(filePath);
+        // Wrap to enable alternate translation file formats (PO, XLIFF, CSV/TSV).
+        // Pass-through if no format was enabled via Loreline.translationFormat();
+        // otherwise the wrap tries each enabled format as a sibling and converts
+        // the first match to a synthesized .lor translation body before handing
+        // it back to loadLocale.
+        handleFile = loreline.translation.TranslationFormats.wrap(handleFile, locale);
+
+        // Determine which Loreline extension we're working with for translation files.
+        // By default, always ".lor" — ".lor.txt" translations are only considered when
+        // built with -D loreline_lor_txt (which restores the previous behavior of
+        // matching the source script's extension).
+        final ext = #if loreline_lor_txt
+            (script.filePath != null && Imports.endsWithLorTxt(script.filePath))
+                ? '.lor.txt'
+                : Imports.lorExtension(filePath);
+        #else
+            '.lor';
+        #end
 
         // Determine where to look for translation files.
         // If filePath ends with .lor / .lor.txt, treat its directory as the lookup base.
@@ -357,6 +369,24 @@ class Loreline {
         return AstUtils.extractTranslations(script);
     }
 
+    /**
+     * Enable or disable runtime support for an alternate translation file format.
+     *
+     * By default, only `.<locale>.lor` files are tried by `loadLocale`. Call this
+     * to opt in to additional formats. Known names:
+     *   - `"po"`   — GNU gettext PO (`.po`)
+     *   - `"xliff"` — XLIFF 1.2 / 2.x (`.xliff`, `.xlf`)
+     *   - `"csv"`  — CSV / TSV (`.csv`, `.tsv`)
+     *
+     * Unknown names are accepted silently (forward-compat for future formats).
+     *
+     * @param name The format identifier (see above)
+     * @param enabled True to enable the format, false to disable
+     */
+    public static function translationFormat(name:String, enabled:Bool):Void {
+        loreline.translation.TranslationFormats.translationFormat(name, enabled);
+    }
+
     /**
      * Generates a translation file body for the given source `script`.
      *
@@ -372,8 +402,20 @@ class Loreline {
      * @param existing (optional) Existing translations to preserve when merging
      * @return The translation file body as a string, ready to write to disk
      */
-    public static function generateTranslationFile(script:Script, ?existing:Map<String, NStringLiteral>):String {
-        return AstUtils.generateTranslationFile(script, existing, new Printer());
+    public static function generateTranslationFile(script:Script, ?existing:Map<String, NStringLiteral>, ?format:String, ?locale:String):String {
+        if (format == null || format == "lor") {
+            return AstUtils.generateTranslationFile(script, existing, new Printer());
+        }
+        if (locale == null || locale == "") {
+            throw new Error("A locale is required when generating a translation file in format '" + format + "'");
+        }
+        return switch (format) {
+            case "po":    loreline.translation.PoTranslation.fromScript(script, existing, locale);
+            case "xliff": loreline.translation.XliffTranslation.fromScript(script, existing, locale);
+            case "csv":   loreline.translation.CsvTranslation.fromScript(script, existing, locale);
+            case "tsv":   loreline.translation.CsvTranslation.tsvFromScript(script, existing, locale);
+            case _: throw new Error("Unknown translation file format: '" + format + "'");
+        }
     }
 
     /**

src/loreline/cli/Cli.hx

@@ -228,6 +228,11 @@ class Cli {
         var fileCount = 0;
         var fileFailCount = 0;
 
+        // Test fixtures exercise every supported translation format.
+        Loreline.translationFormat("po", true);
+        Loreline.translationFormat("xliff", true);
+        Loreline.translationFormat("csv", true);
+
         if (FileSystem.exists(path) && FileSystem.isDirectory(path)) {
             var dir = path;
             for (file in FileSystem.readDirectory(dir)) {
@@ -615,6 +620,17 @@ class Cli {
         final clearIds = argFlag(args, "clear");
         final lang = argValue(args, "lang", !clearIds);
         final generateIds = argFlag(args, "auto-ids");
+        var format = argValue(args, "format", false);
+        if (format == null || format == "") format = "lor";
+        if (format != "lor" && format != "po" && format != "xliff" && format != "csv" && format != "tsv") {
+            fail('Unsupported translation format: $format (expected one of: lor, po, xliff, csv, tsv)');
+        }
+
+        // Enable alternate translation formats so that an existing file can be
+        // read back as the merge baseline.
+        Loreline.translationFormat("po", true);
+        Loreline.translationFormat("xliff", true);
+        Loreline.translationFormat("csv", true);
 
         if (!FileSystem.exists(file) || FileSystem.isDirectory(file))
             fail('Invalid file: $file');
@@ -636,20 +652,25 @@ class Cli {
                 script = Loreline.parse(content, file, handleFile);
             }
 
-            final basePath = file.substring(0, file.length - 4);
-            final translationPath = basePath + "." + lang + ".lor";
+            final basePath = file.uSubstring(0, file.uLength() - 4);
+            final translationPath = basePath + "." + lang + "." + format;
 
             var existingTranslations:Map<String, Node.NStringLiteral> = null;
             if (FileSystem.exists(translationPath)) {
                 final transContent = File.getContent(translationPath);
                 if (transContent.trim().length > 0) {
-                    final transScript = Loreline.parse(transContent, translationPath, handleFile);
-                    if (transScript != null)
-                        existingTranslations = AstUtils.extractTranslations(transScript);
+                    final lorBody = (format == "lor")
+                        ? transContent
+                        : convertExistingToLor(transContent, format, lang);
+                    if (lorBody != null && lorBody.trim().length > 0) {
+                        final transScript = Loreline.parse(lorBody, translationPath, handleFile);
+                        if (transScript != null)
+                            existingTranslations = AstUtils.extractTranslations(transScript);
+                    }
                 }
             }
 
-            final output = AstUtils.generateTranslationFile(script, existingTranslations, new Printer());
+            final output = Loreline.generateTranslationFile(script, existingTranslations, format, lang);
             File.saveContent(translationPath, output);
 
             print('Translation file ' + (existingTranslations != null ? 'updated' : 'created') + ': ' + translationPath);
@@ -669,6 +690,16 @@ class Cli {
 
     }
 
+    function convertExistingToLor(content:String, format:String, locale:String):String {
+        return switch (format) {
+            case "po":    loreline.translation.PoTranslation.toLoreline(content, locale);
+            case "xliff": loreline.translation.XliffTranslation.toLoreline(content, locale);
+            case "csv":   loreline.translation.CsvTranslation.toLoreline(content, locale);
+            case "tsv":   loreline.translation.CsvTranslation.tsvToLoreline(content, locale);
+            case _: null;
+        }
+    }
+
     function play(file:String) {
 
         print("");

src/loreline/lib/linc/linc_Loreline.cpp

@@ -1241,6 +1241,27 @@ LORELINE_PUBLIC Loreline_Translations* Loreline_loadLocale(
     return slot.result;
 }
 
+/* ── Translation formats ────────────────────────────────────────────────── */
+
+static LORELINE_NOINLINE void Loreline_translationFormat_hx(
+    Loreline_String name,
+    bool enabled
+) {
+    LORELINE_HX_BEGIN
+    ::String hxName = linc_toHxString(name);
+    ::loreline::Loreline_obj::translationFormat(hxName, enabled);
+    LORELINE_HX_END
+}
+
+LORELINE_PUBLIC void Loreline_translationFormat(
+    Loreline_String name,
+    bool enabled
+) {
+    LORELINE_BEGIN_CALL
+    Loreline_translationFormat_hx(name, enabled);
+    LORELINE_END_CALL
+}
+
 /* ── Play ───────────────────────────────────────────────────────────────── */
 
 static LORELINE_NOINLINE void Loreline_play_hx(