@gjsify/vite-plugin-gettext 0.2.0

package/src/index.ts

@@ -0,0 +1,11 @@
+export { gettextPlugin } from "./gettext.js";
+export { msgfmtPlugin } from "./msgfmt.js";
+export { xgettextPlugin } from "./xgettext.js";
+export { po2jsonPlugin } from "./po2json.js";
+export type {
+  GettextPluginOptions,
+  MsgfmtPluginOptions,
+  MsgfmtFormat,
+  XGettextPluginOptions,
+} from "./types.js";
+export * from "./utils.js";

package/src/msgfmt.ts

@@ -0,0 +1,209 @@
+import { type Plugin } from "vite";
+import { execa } from "execa";
+import path from "node:path";
+import type { MsgfmtPluginOptions, MsgfmtFormat } from "./types.js";
+import {
+  checkDependencies,
+  findAvailableLanguages,
+  ensureDirectory,
+} from "./utils.js";
+
+/**
+ * Get output file extension based on the format
+ * @param format The output format
+ * @returns The file extension for the given format
+ */
+function getOutputExtension(format: MsgfmtFormat): string {
+  switch (format) {
+    case "mo":
+      return ".mo";
+    case "java":
+    case "java2":
+      return ".class";
+    case "csharp":
+      return ".dll";
+    case "csharp-resources":
+      return ".resources.dll";
+    case "tcl":
+      return ".msg";
+    case "desktop":
+      return ".desktop";
+    case "xml":
+      return ".xml";
+    case "json":
+      return ".json";
+    case "qt":
+      return ".qm";
+    default:
+      return ".mo";
+  }
+}
+
+/**
+ * Creates a Vite plugin that compiles PO translation files to various formats
+ * Supports metainfo files with special processing
+ * @param options Configuration options for the plugin
+ * @returns A Vite plugin that handles PO compilation
+ */
+export function msgfmtPlugin(options: MsgfmtPluginOptions): Plugin {
+  const {
+    poDirectory,
+    outputDirectory,
+    domain = "messages",
+    format = "mo",
+    templateFile,
+    verbose = false,
+    msgfmtOptions = [],
+    useLocaleStructure = true,
+  } = options;
+
+  const pluginName = "vite-plugin-msgfmt";
+
+  async function compilePoFiles() {
+    try {
+      // Check if PO directory exists
+      try {
+        await ensureDirectory(poDirectory);
+      } catch {
+        if (verbose) {
+          console.log(
+            `[${pluginName}] PO directory ${poDirectory} does not exist yet, skipping compilation`
+          );
+        }
+        return;
+      }
+
+      // Create output directory
+      await ensureDirectory(outputDirectory);
+
+      // For XML format, we can use the bulk mode if a template is provided
+      if (format === "xml" && templateFile) {
+        // Use bulk mode for XML format
+        const outputFile = path.join(
+          outputDirectory,
+          options.filename || `${domain}${getOutputExtension(format)}`
+        );
+
+        if (verbose) {
+          console.log(
+            `[${pluginName}] Compiling all languages to ${outputFile} using bulk mode`
+          );
+        }
+
+        // Base arguments for bulk mode
+        const args = [
+          "--output-file=" + outputFile,
+          "--xml",
+          "--template=" + templateFile,
+          "-d",
+          poDirectory,
+        ];
+
+        // Add any additional options
+        args.push(...msgfmtOptions);
+
+        if (verbose) {
+          console.log(`[${pluginName}] Running msgfmt with: ${args.join(" ")}`);
+        }
+
+        await execa("msgfmt", args);
+      } else {
+        // Find available languages for individual processing
+        const languages = await findAvailableLanguages(
+          poDirectory,
+          pluginName,
+          verbose
+        );
+
+        if (languages.length === 0) {
+          if (verbose) {
+            console.log(`[${pluginName}] No translation files found`);
+          }
+          return;
+        }
+
+        // Process each language individually for other formats
+        for (const lang of languages) {
+          const poFile = path.join(poDirectory, `${lang}.po`);
+
+          let outputPath: string;
+          let outputFile: string;
+
+          if (useLocaleStructure && format === "mo") {
+            // Use standard gettext locale structure
+            outputPath = path.join(
+              outputDirectory,
+              "locale",
+              lang,
+              "LC_MESSAGES"
+            );
+            outputFile = path.join(
+              outputPath,
+              options.filename || `${domain}${getOutputExtension(format)}`
+            );
+          } else {
+            // Use simple language-based structure
+            outputPath = path.join(outputDirectory, lang);
+            outputFile = path.join(
+              outputPath,
+              options.filename || `${domain}${getOutputExtension(format)}`
+            );
+          }
+
+          // Create the directory structure
+          await ensureDirectory(outputPath);
+
+          if (verbose) {
+            console.log(`[${pluginName}] Compiling ${poFile} to ${outputFile}`);
+          }
+
+          // Base arguments
+          const args = ["--output-file=" + outputFile];
+
+          // Add format-specific arguments
+          args.push(`--${format}`);
+
+          // Add any additional options
+          args.push(...msgfmtOptions);
+
+          // Add the input PO file
+          args.push(poFile);
+
+          if (verbose) {
+            console.log(
+              `[${pluginName}] Running msgfmt with: ${args.join(" ")}`
+            );
+          }
+
+          await execa("msgfmt", args);
+        }
+      }
+    } catch (error) {
+      throw new Error(`Failed to compile files: ${error}`);
+    }
+  }
+
+  return {
+    name: pluginName,
+
+    async buildStart() {
+      await checkDependencies("msgfmt", pluginName, verbose);
+      await compilePoFiles();
+    },
+
+    configureServer(server) {
+      server.watcher.add(poDirectory);
+
+      server.watcher.on("change", async (file) => {
+        if (file.endsWith(".po")) {
+          if (verbose) {
+            console.log(
+              `[${pluginName}] PO file changed: ${file}, recompiling`
+            );
+          }
+          await compilePoFiles();
+        }
+      });
+    },
+  };
+}

package/src/po2json.ts

@@ -0,0 +1,281 @@
+import { type Plugin } from "vite";
+import path from "node:path";
+import fs from "node:fs/promises";
+import * as gettextParser from "gettext-parser";
+import type { GettextPo2JsonPluginOptions } from "./types.js";
+import {
+  checkDependencies,
+  findAvailableLanguages,
+  ensureDirectory,
+} from "./utils.js";
+
+/**
+ * Simplifies the gettext-parser output to a clean key-value object
+ * where the key is the original text and the value is the translation
+ * @param translations The parsed PO file from gettext-parser
+ * @returns A simplified object with just the translations
+ */
+function simplifyTranslations(translations: any): Record<string, string> {
+  const result: Record<string, string> = {};
+
+  // Go through all translation contexts
+  Object.keys(translations.translations).forEach((context) => {
+    const contextTranslations = translations.translations[context];
+
+    // Skip the header (empty msgid)
+    Object.keys(contextTranslations).forEach((key) => {
+      if (key === "") return;
+
+      const translation = contextTranslations[key];
+      // Get the original text (msgid)
+      const original = translation.msgid;
+      // Get the translated text (first item in msgstr array)
+      const translated = translation.msgstr[0];
+
+      // Only add the translation if it exists and is not empty
+      if (translated && translated.trim() !== "") {
+        result[original] = translated;
+      }
+    });
+  });
+
+  return result;
+}
+
+/**
+ * Creates a dictionary of all original strings from all translations
+ * For the default language, we need to gather all possible keys
+ * @param jsonDirectory Directory with JSON files
+ * @param allTranslations Collection of all translations
+ * @param defaultLanguage The default language code
+ * @param verbose Whether to log verbose messages
+ * @param pluginName The name of the plugin
+ * @param additionalTranslations Additional translations to include
+ * @returns Object with original strings as both keys and values
+ */
+async function createDefaultLanguageJson(
+  jsonDirectory: string,
+  allTranslations: Record<string, Record<string, string>>,
+  defaultLanguage: string,
+  verbose: boolean,
+  pluginName: string,
+  additionalTranslations: Record<string, string> = {}
+): Promise<void> {
+  // Create a set of all original strings from all translations
+  const allOriginalStrings = new Set<string>();
+
+  // Collect all original strings from all translations
+  Object.values(allTranslations).forEach((translations) => {
+    Object.keys(translations).forEach((key) => {
+      allOriginalStrings.add(key);
+    });
+  });
+
+  // Create the default language JSON with keys matching values
+  const defaultLanguageJson: Record<string, string> = {};
+  allOriginalStrings.forEach((str) => {
+    defaultLanguageJson[str] = str;
+  });
+
+  // Process additional translations
+  const finalTranslations = { ...defaultLanguageJson };
+
+  // For each additional translation, try to find a translation or use the original
+  Object.entries(additionalTranslations).forEach(([key, originalText]) => {
+    // If there's a translation for the original text, use it
+    if (defaultLanguageJson[originalText]) {
+      finalTranslations[key] = defaultLanguageJson[originalText];
+    } else {
+      // Otherwise use the original text
+      finalTranslations[key] = originalText;
+    }
+  });
+
+  // Write the default language file with .default.json extension
+  const defaultLangDefaultFile = path.join(
+    jsonDirectory,
+    `${defaultLanguage}.default.json`
+  );
+
+  if (verbose) {
+    console.log(
+      `[${pluginName}] Creating default language file: ${defaultLangDefaultFile}`
+    );
+  }
+
+  await fs.writeFile(
+    defaultLangDefaultFile,
+    JSON.stringify(finalTranslations, null, 2)
+  );
+}
+
+/**
+ * Creates a Vite plugin that converts PO translation files to JSON format
+ * The JSON files are placed in the specified output directory
+ * @param options Configuration options for the plugin
+ * @returns A Vite plugin that handles PO to JSON conversion
+ */
+export function po2jsonPlugin(options: GettextPo2JsonPluginOptions): Plugin {
+  const {
+    poDirectory,
+    jsonDirectory,
+    defaultLanguage = "en",
+    verbose = false,
+    additionalTranslations = {},
+  } = options;
+
+  const pluginName = "vite-plugin-gettext-po2json";
+
+  async function convertPoToJson() {
+    try {
+      // Check if PO directory exists
+      try {
+        await ensureDirectory(poDirectory);
+      } catch {
+        if (verbose) {
+          console.log(
+            `[${pluginName}] PO directory ${poDirectory} does not exist yet, skipping conversion`
+          );
+        }
+        return;
+      }
+
+      // Find available languages
+      const languages = await findAvailableLanguages(
+        poDirectory,
+        pluginName,
+        verbose
+      );
+
+      if (languages.length === 0) {
+        if (verbose) {
+          console.log(`[${pluginName}] No translation files found`);
+        }
+        return;
+      }
+
+      // Create JSON directory
+      await ensureDirectory(jsonDirectory);
+
+      // Collection of all translations to create the default language file
+      const allTranslations: Record<string, Record<string, string>> = {};
+
+      // Skip the default language if it exists in the list
+      const nonDefaultLanguages = languages.filter(
+        (lang) => lang !== defaultLanguage
+      );
+
+      // Handle default language if it exists in the list
+      if (languages.includes(defaultLanguage)) {
+        const poFile = path.join(poDirectory, `${defaultLanguage}.po`);
+        const jsonFile = path.join(jsonDirectory, `${defaultLanguage}.json`);
+
+        if (verbose) {
+          console.log(
+            `[${pluginName}] Converting default language ${poFile} to ${jsonFile}`
+          );
+        }
+
+        // Read and parse PO file
+        const poContent = await fs.readFile(poFile);
+        const translations = gettextParser.po.parse(poContent);
+
+        // Convert the translations to a simple JSON object
+        const simplifiedTranslations = simplifyTranslations(translations);
+
+        // Process additional translations for default language
+        const finalTranslations = { ...simplifiedTranslations };
+
+        // For each additional translation, add it to the default language file
+        Object.entries(additionalTranslations).forEach(
+          ([key, originalText]) => {
+            finalTranslations[key] = originalText;
+          }
+        );
+
+        // Write JSON file for default language
+        await fs.writeFile(
+          jsonFile,
+          JSON.stringify(finalTranslations, null, 2)
+        );
+      }
+
+      // Add additional translations for all languages
+      for (const lang of nonDefaultLanguages) {
+        const poFile = path.join(poDirectory, `${lang}.po`);
+        const jsonFile = path.join(jsonDirectory, `${lang}.json`);
+
+        if (verbose) {
+          console.log(`[${pluginName}] Converting ${poFile} to ${jsonFile}`);
+        }
+
+        // Read and parse PO file
+        const poContent = await fs.readFile(poFile);
+        const translations = gettextParser.po.parse(poContent);
+
+        // Convert the translations to a simple JSON object
+        const simplifiedTranslations = simplifyTranslations(translations);
+
+        // Store translations for creating the default language file
+        allTranslations[lang] = simplifiedTranslations;
+
+        // Process additional translations
+        const finalTranslations = { ...simplifiedTranslations };
+
+        // For each additional translation, try to find a translation or use the original
+        Object.entries(additionalTranslations).forEach(
+          ([key, originalText]) => {
+            // If there's a translation for the original text, use it
+            if (simplifiedTranslations[originalText]) {
+              finalTranslations[key] = simplifiedTranslations[originalText];
+            } else {
+              // Otherwise use the original text
+              finalTranslations[key] = originalText;
+            }
+          }
+        );
+
+        // Write JSON file
+        await fs.writeFile(
+          jsonFile,
+          JSON.stringify(finalTranslations, null, 2)
+        );
+      }
+
+      // Create the default language file (with all original strings as both keys and values)
+      await createDefaultLanguageJson(
+        jsonDirectory,
+        allTranslations,
+        defaultLanguage,
+        verbose,
+        pluginName,
+        additionalTranslations
+      );
+    } catch (error) {
+      throw new Error(`Failed to convert PO files to JSON: ${error}`);
+    }
+  }
+
+  return {
+    name: pluginName,
+
+    async buildStart() {
+      await convertPoToJson();
+    },
+
+    configureServer(server) {
+      server.watcher.add(poDirectory);
+
+      server.watcher.on("change", async (file) => {
+        if (file.endsWith(".po")) {
+          if (verbose) {
+            console.log(
+              `[${pluginName}] PO file changed: ${file}, reconverting`
+            );
+          }
+          await convertPoToJson();
+        }
+      });
+    },
+  };
+}

package/src/types.ts

@@ -0,0 +1,120 @@
+/**
+ * Configuration options for the xgettext plugin
+ * Used to extract translatable strings from source files
+ */
+export interface XGettextPluginOptions {
+  /** Glob patterns for source files to extract strings from */
+  sources: string[];
+  /** Output path for the POT template file */
+  output: string;
+  /** The gettext domain name, defaults to 'messages' */
+  domain?: string;
+  /** Keywords to look for when extracting strings, defaults to ['_', 'gettext', 'ngettext'] */
+  keywords?: string[];
+  /** Additional options to pass to xgettext command */
+  xgettextOptions?: string[];
+  /** Enable verbose logging */
+  verbose?: boolean;
+  /** Automatically update PO files after POT changes */
+  autoUpdatePo?: boolean;
+  /** Version of the POT file, defaults to '1.0' */
+  version?: string;
+  /** Preset to use for extracting strings, defaults to 'glib' */
+  preset?: "glib";
+  /** URL for reporting bugs in the POT file */
+  msgidBugsAddress?: string;
+  /** Copyright holder to set in the POT file */
+  copyrightHolder?: string;
+}
+
+/**
+ * Configuration options for the gettext plugin
+ * Used to compile PO files to binary MO format
+ */
+export interface GettextPluginOptions {
+  /** Directory containing PO translation files */
+  poDirectory: string;
+  /** Output directory for compiled MO files */
+  moDirectory: string;
+  /** Filename of the MO file, defaults to 'messages.mo' */
+  filename?: string;
+  /** Enable verbose logging */
+  verbose?: boolean;
+}
+
+/**
+ * Output format types for msgfmt
+ */
+export type MsgfmtFormat =
+  | "mo"
+  | "java"
+  | "java2"
+  | "csharp"
+  | "csharp-resources"
+  | "tcl"
+  | "desktop"
+  | "xml"
+  | "json"
+  | "qt";
+
+/**
+ * Configuration options for the msgfmt plugin
+ * Used to compile PO files to various formats including binary MO
+ */
+export interface MsgfmtPluginOptions {
+  /** Directory containing PO translation files */
+  poDirectory: string;
+  /** Output directory for compiled files */
+  outputDirectory: string;
+  /** The gettext domain name, defaults to 'messages' */
+  domain?: string;
+  /** Output filename, defaults to 'messages.mo' */
+  filename?: string;
+  /** Output format, defaults to 'mo' */
+  format?: MsgfmtFormat;
+  /** Path to template file, required for XML format */
+  templateFile?: string;
+  /** Enable verbose logging */
+  verbose?: boolean;
+  /** Additional options to pass to msgfmt command */
+  msgfmtOptions?: string[];
+  /** Whether to use the standard locale structure (locale/LANG/LC_MESSAGES/domain.mo) */
+  useLocaleStructure?: boolean;
+}
+
+export interface PluginOptions {
+  pluginName: string;
+  verbose?: boolean;
+}
+
+/**
+ * Options for the PO to JSON conversion plugin
+ */
+export interface GettextPo2JsonPluginOptions {
+  /**
+   * Directory containing PO files
+   */
+  poDirectory: string;
+
+  /**
+   * Directory where JSON files will be saved
+   */
+  jsonDirectory: string;
+
+  /**
+   * Default language code (default: 'en')
+   */
+  defaultLanguage?: string;
+
+  /**
+   * Enable verbose logging
+   */
+  verbose?: boolean;
+
+  /**
+   * Additional translations to include in all language files
+   * Keys are identifiers and values are the English text
+   * The English text will be translated for non-default languages if translations exist
+   */
+  additionalTranslations?: Record<string, string>;
+}