@gtkx/cli 1.4.0 → 1.5.0

package/src/deploy/freedesktop/localize.ts

@@ -0,0 +1,144 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import type { CatalogProject } from "../../i18n/catalogs.js";
+import type { StagedMetadata } from "../payload/stage.js";
+import { metadataTemplateFile, type MetadataTemplateKind } from "../../i18n/metadata-templates.js";
+import { runCliTool } from "../../internal/run-cli-tool.js";
+
+type MergeMode = "--desktop" | "--xml";
+
+type MergeRequest = {
+    mode: MergeMode;
+    stem: string;
+    extension: string;
+    template: string;
+};
+
+type MetadataTemplate = {
+    contents: string;
+    path: string;
+    relativePath: string;
+};
+
+const metadataTemplates = (project: CatalogProject, metadata: StagedMetadata): MetadataTemplate[] => {
+    const template = (kind: MetadataTemplateKind, contents: string): MetadataTemplate => {
+        const { path, relativePath } = metadataTemplateFile(project, kind);
+
+        return { contents, path, relativePath };
+    };
+
+    return [
+        template("desktop", metadata.desktopEntry),
+        template("metainfo.xml", metadata.metainfo),
+        ...(metadata.mimePackage === null ? [] : [template("mime.xml", metadata.mimePackage)]),
+    ];
+};
+
+const mergeCatalogs = (project: CatalogProject, workDir: string, request: MergeRequest): string => {
+    const { extension, mode, stem, template } = request;
+    let current = join(workDir, `${stem}-source${extension}`);
+    writeFileSync(current, template);
+
+    for (const [index, catalog] of project.catalogs.entries()) {
+        const output = join(workDir, `${stem}-${String(index)}${extension}`);
+
+        runCliTool({
+            tool: "msgfmt",
+            args: [
+                mode,
+                `--template=${current}`,
+                `--locale=${catalog.locale}`,
+                `--output-file=${output}`,
+                catalog.path,
+            ],
+            target: catalog.path,
+        });
+
+        current = output;
+    }
+
+    return readFileSync(current, "utf8");
+};
+
+const localizeMetadata = (metadata: StagedMetadata, project: CatalogProject | null): StagedMetadata => {
+    if (project === null || project.catalogs.length === 0) {
+        return metadata;
+    }
+
+    const workDir = mkdtempSync(join(tmpdir(), "gtkx-deploy-metadata-"));
+
+    try {
+        return {
+            desktopEntry: mergeCatalogs(project, workDir, {
+                mode: "--desktop",
+                stem: "application",
+                extension: ".desktop",
+                template: metadata.desktopEntry,
+            }),
+            metainfo: mergeCatalogs(project, workDir, {
+                mode: "--xml",
+                stem: "metainfo",
+                extension: ".metainfo.xml",
+                template: metadata.metainfo,
+            }),
+            mimePackage: metadata.mimePackage === null
+                ? null
+                : mergeCatalogs(project, workDir, {
+                        mode: "--xml",
+                        stem: "mime",
+                        extension: ".xml",
+                        template: metadata.mimePackage,
+                    }),
+        };
+    } finally {
+        rmSync(workDir, { recursive: true, force: true });
+    }
+};
+
+const extractMetadataMessages = (
+    metadata: StagedMetadata,
+    project: CatalogProject,
+    catalogTemplate?: string,
+): void => {
+    const potPath = catalogTemplate ?? join(project.poDir, `${project.domain}.pot`);
+
+    if (!existsSync(potPath)) {
+        throw new Error(`Cannot add the generated metadata to the missing catalog template: ${potPath}`);
+    }
+
+    const templates = metadataTemplates(project, metadata);
+    const firstTemplate = templates[0];
+
+    if (firstTemplate === undefined) {
+        throw new Error("Cannot extract metadata messages without a generated template");
+    }
+
+    const metadataDir = dirname(firstTemplate.path);
+    mkdirSync(metadataDir, { recursive: true });
+
+    try {
+        for (const template of templates) {
+            writeFileSync(template.path, template.contents);
+        }
+
+        runCliTool({
+            tool: "xgettext",
+            args: [
+                "--join-existing",
+                "--force-po",
+                "--from-code=UTF-8",
+                `--output=${potPath}`,
+                ...templates.map((template) => template.relativePath),
+            ],
+            target: potPath,
+            options: { cwd: project.root },
+        });
+    } finally {
+        for (const template of templates) {
+            rmSync(template.path, { force: true });
+        }
+    }
+};
+
+export { extractMetadataMessages, localizeMetadata };

package/src/deploy/install-hints.ts

@@ -43,8 +43,13 @@ const PACKAGE_FOR_TOOL: Record<string, FamilyPackages> = {
         fedora: "flatpak-builder",
         suse: "flatpak-builder",
     },
+    msgfmt: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
+    msginit: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
+    msggrep: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
+    msgmerge: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
     strip: { arch: "binutils", debian: "binutils", fedora: "binutils", suse: "binutils" },
     tar: { arch: "tar", debian: "tar", fedora: "tar", suse: "tar" },
+    xgettext: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
 };
 
 const GENERATOR_SOURCE = "git+https://github.com/flatpak/flatpak-builder-tools.git#subdirectory=node";

package/src/deploy/payload/launcher.ts

@@ -18,6 +18,8 @@ const renderLauncher = (settings: DeploySettings): string => {
         "set -e",
         'self=$(readlink -f "$0")',
         'prefix=$(dirname "$(dirname "$self")")',
+        'GTKX_LOCALE_DIR="$prefix/share/locale"',
+        "export GTKX_LOCALE_DIR",
         ...(shouldUseCompileCache ? compileCacheLines(settings.binaryName) : []),
         `exec "${libDir}/${NODE_FILENAME}" "${libDir}/${BUNDLE_FILENAME}" "$@"`,
         "",

package/src/deploy/payload/stage.ts

@@ -2,12 +2,12 @@ import { sortStringsBy } from "@gtkx/utils";
 import { existsSync, rmSync } from "node:fs";
 import { join, resolve } from "node:path";
 import type { DeploySettings, DeployTargetName, NodeRuntime, NoticeSection, StagedFile } from "../types.js";
+import { LOCALE_DIRNAME } from "../../i18n/catalogs.js";
 import { BUILD_MANIFEST_FILENAME } from "../../internal/build-manifest.js";
 import { listFilesRecursive } from "../../internal/list-files.js";
 import { BUNDLE_FILENAME } from "../../vite-plugins/esm-extension.js";
 import { renderCopyright } from "../freedesktop/copyright.js";
 import { renderDbusService } from "../freedesktop/dbus-service.js";
-import { renderDesktopEntry } from "../freedesktop/desktop-entry.js";
 import { renderNotices } from "../notices/render.js";
 import { copyInto, EXECUTABLE_MODE, executableModeFor, writeInto } from "./copy-tree.js";
 import { stageIcons } from "./icons.js";
@@ -36,6 +36,7 @@ const SHARE_MIME_PACKAGES = "share/mime/packages";
 const SHARE_DOC = "share/doc";
 const SHARE_LICENSES = "share/licenses";
 const SHARE_DBUS_SERVICES = "share/dbus-1/services";
+const SHARE_LOCALE = `share/${LOCALE_DIRNAME}`;
 
 const PREFIX_FOR: Record<DeployTargetName, string> = {
     appimage: "/usr",
@@ -53,6 +54,8 @@ const isIconAsset = (rel: string): boolean => rel === DIST_ICONS_DIR || rel.star
 const isBuildMetadata = (rel: string): boolean =>
     rel === BUILD_MANIFEST_FILENAME || rel === LEGACY_PACKAGES_MANIFEST_FILENAME;
 
+const isLocaleAsset = (rel: string): boolean => rel === LOCALE_DIRNAME || rel.startsWith(`${LOCALE_DIRNAME}/`);
+
 const nodeLicenseDestination = (settings: DeploySettings): string =>
     `${licenseDirFor(settings)}/${NODE_FILENAME}/${NODE_LICENSE_FILENAME}`;
 
@@ -64,10 +67,14 @@ const stageRuntimeFiles = (settings: DeploySettings, root: string): StagedFile[]
     }
 
     return listFilesRecursive(dist)
-        .filter((file) => !isIconAsset(file.rel) && !isBuildMetadata(file.rel))
+        .filter((file) => !isIconAsset(file.rel) && !isBuildMetadata(file.rel) && !isLocaleAsset(file.rel))
         .map((file) => copyInto(root, join(libDirFor(settings), file.rel), file.absPath));
 };
 
+const stageCatalogs = (settings: DeploySettings, root: string): StagedFile[] =>
+    listFilesRecursive(join(settings.paths.dist, LOCALE_DIRNAME))
+        .map((file) => copyInto(root, join(SHARE_LOCALE, file.rel), file.absPath));
+
 const stageNodeBinary = (settings: DeploySettings, root: string, node: NodeRuntime | null): StagedFile[] =>
     node === null ? [] : [copyInto(root, join(libDirFor(settings), NODE_FILENAME), node.path, EXECUTABLE_MODE)];
 
@@ -104,6 +111,7 @@ const stagePayload = ({ settings, node, metadata }: StageRequest): StagedFile[]
         writeInto(root, join("bin", settings.binaryName), renderLauncher(settings), EXECUTABLE_MODE),
         ...stageNodeBinary(settings, root, node),
         ...stageRuntimeFiles(settings, root),
+        ...stageCatalogs(settings, root),
         ...stageMetadata(settings, root, metadata),
         ...stageIcons(settings, root),
         ...stageSchemas(settings, root),
@@ -111,7 +119,18 @@ const stagePayload = ({ settings, node, metadata }: StageRequest): StagedFile[]
     ]);
 };
 
-const stageActivation = (settings: DeploySettings, root: string, target: DeployTargetName): StagedFile[] => {
+const withoutDbusActivation = (desktopEntry: string): string =>
+    desktopEntry
+        .split("\n")
+        .filter((line) => line !== "DBusActivatable=true")
+        .join("\n");
+
+const stageActivation = (
+    settings: DeploySettings,
+    root: string,
+    target: DeployTargetName,
+    metadata: StagedMetadata,
+): StagedFile[] => {
     if (!settings.isDbusActivatable) {
         return [];
     }
@@ -120,7 +139,7 @@ const stageActivation = (settings: DeploySettings, root: string, target: DeployT
         return [writeInto(
             root,
             join(SHARE_APPLICATIONS, `${settings.applicationId}.desktop`),
-            renderDesktopEntry({ ...settings, isDbusActivatable: false }),
+            withoutDbusActivation(metadata.desktopEntry),
         )];
     }
 
@@ -131,11 +150,16 @@ const stageActivation = (settings: DeploySettings, root: string, target: DeployT
     )];
 };
 
-const stageOverlay = (settings: DeploySettings, target: DeployTargetName, notices: NoticeSection[]): StagedFile[] => {
+const stageOverlay = (
+    settings: DeploySettings,
+    target: DeployTargetName,
+    notices: NoticeSection[],
+    metadata: StagedMetadata,
+): StagedFile[] => {
     const root = join(settings.paths.overlay, target);
     rmSync(root, { recursive: true, force: true, maxRetries: 5 });
     const licenseFile = settings.paths.licenseFile;
-    const activation = stageActivation(settings, root, target);
+    const activation = stageActivation(settings, root, target, metadata);
 
     if (target === "deb") {
         return [
@@ -154,11 +178,12 @@ const stageOverlay = (settings: DeploySettings, target: DeployTargetName, notice
 const stageOverlays = (
     settings: DeploySettings,
     notices: NoticeSection[],
+    metadata: StagedMetadata,
 ): Record<DeployTargetName, StagedFile[]> => ({
-    appimage: stageOverlay(settings, "appimage", notices),
-    deb: stageOverlay(settings, "deb", notices),
-    flatpak: stageOverlay(settings, "flatpak", notices),
-    rpm: stageOverlay(settings, "rpm", notices),
+    appimage: stageOverlay(settings, "appimage", notices, metadata),
+    deb: stageOverlay(settings, "deb", notices, metadata),
+    flatpak: stageOverlay(settings, "flatpak", notices, metadata),
+    rpm: stageOverlay(settings, "rpm", notices, metadata),
 });
 
 export {

package/src/deploy/run-deploy.ts

@@ -1,6 +1,6 @@
 import { loadConfig } from "@gtkx/config";
 import { info, warn } from "@gtkx/utils";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 import type {
     DeployArtifact,
@@ -12,7 +12,19 @@ import type {
 } from "./types.js";
 import { build as buildApp } from "../builder.js";
 import { ensureGenerated } from "../codegen/run-codegen.js";
+import { replaceCatalogTemplate } from "../i18n/catalog-template.js";
+import {
+    type CatalogProject,
+    compileCatalogs,
+    LOCALE_DIRNAME,
+    requiresCatalogInitialization,
+    resolveCatalogProject,
+    synchronizeCatalogs,
+} from "../i18n/catalogs.js";
+import { extractSourceCatalogTo } from "../i18n/source-messages.js";
+import { discoverSourceFiles } from "../internal/source-imports.js";
 import { renderDesktopEntry } from "./freedesktop/desktop-entry.js";
+import { extractMetadataMessages, localizeMetadata } from "./freedesktop/localize.js";
 import { renderMetainfo } from "./freedesktop/metainfo.js";
 import { renderMimePackage } from "./freedesktop/mime-package.js";
 import { validateDesktopEntry, validateMetainfo } from "./freedesktop/validate.js";
@@ -32,10 +44,15 @@ import {
     DESKTOP_FILE_VALIDATE,
     FLATPAK_NODE_GENERATOR,
     FLATPAK_NODE_GENERATOR_PNPM,
+    MSGFMT,
+    MSGGREP,
+    MSGINIT,
+    MSGMERGE,
     probeTools,
     STRIP,
     TAR,
     warnMissingOptional,
+    XGETTEXT,
 } from "./tools.js";
 
 type DeployOptions = {
@@ -47,6 +64,14 @@ type DeployOptions = {
     shouldSkipBuild: boolean;
 };
 
+type PreflightRequest = {
+    targets: DeployTarget[];
+    settings: DeploySettings;
+    project: CatalogProject | null;
+    shouldPrintManifests: boolean;
+    shouldSkipBuild: boolean;
+};
+
 const BUILD_MODE = "production";
 const BYTES_PER_MIB = 1024 * 1024;
 const WEBKIT_LIBRARY = "WebKit-6.0";
@@ -198,12 +223,50 @@ const runtimeToolsFor = (targets: DeployTarget[], settings: DeploySettings): Dep
     return node.shouldStrip === false ? archiveTools : [...archiveTools, STRIP];
 };
 
-const preflight = (targets: DeployTarget[], settings: DeploySettings, shouldPrintManifests: boolean): void => {
+const mutableCatalogTools = (project: CatalogProject): DeployTool[] => {
+    if (project.catalogs.length === 0) {
+        return [MSGGREP, XGETTEXT];
+    }
+
+    return [
+        MSGFMT,
+        MSGGREP,
+        ...(requiresCatalogInitialization(project) ? [MSGINIT] : []),
+        MSGMERGE,
+        XGETTEXT,
+    ];
+};
+
+const catalogTools = (project: CatalogProject | null, shouldSkipBuild: boolean): DeployTool[] => {
+    if (project === null) {
+        return [];
+    }
+
+    if (!shouldSkipBuild) {
+        return mutableCatalogTools(project);
+    }
+
+    return project.catalogs.length === 0 ? [] : [MSGFMT];
+};
+
+const preflight = ({
+    targets,
+    settings,
+    project,
+    shouldPrintManifests,
+    shouldSkipBuild,
+}: PreflightRequest): void => {
     const packagerTools = shouldPrintManifests
         ? []
         : [...runtimeToolsFor(targets, settings), ...targets.flatMap((target) => target.tools)];
 
-    const required = [DESKTOP_FILE_VALIDATE, APPSTREAMCLI, ...sourceModeTools(targets, settings)];
+    const required = [
+        DESKTOP_FILE_VALIDATE,
+        APPSTREAMCLI,
+        ...catalogTools(project, shouldSkipBuild),
+        ...sourceModeTools(targets, settings),
+    ];
+
     const report = probeTools([...required, ...packagerTools]);
     assertTools(report);
     warnMissingOptional(report);
@@ -229,19 +292,55 @@ const loadSettings = async (options: DeployOptions): Promise<DeploySettings> =>
     return resolveDeploySettings({ root, config, outDirOverride: options.outDir });
 };
 
+const synchronizeMetadataCatalogs = async (
+    settings: DeploySettings,
+    templates: StagedMetadata,
+    project: CatalogProject | null,
+): Promise<void> => {
+    if (project === null) {
+        return;
+    }
+
+    const srcDir = join(project.root, "src");
+    const sourceFiles = discoverSourceFiles(existsSync(srcDir) ? srcDir : project.root);
+    const stagingDir = mkdtempSync(join(project.poDir, ".gtkx-deploy-i18n-"));
+    const stagedTemplate = join(stagingDir, `${project.domain}.pot`);
+    const template = join(project.poDir, `${project.domain}.pot`);
+
+    try {
+        await extractSourceCatalogTo(project, sourceFiles, stagedTemplate);
+        extractMetadataMessages(templates, project, stagedTemplate);
+        replaceCatalogTemplate(stagedTemplate, template);
+        synchronizeCatalogs(project);
+        compileCatalogs(project, join(settings.paths.dist, LOCALE_DIRNAME));
+    } finally {
+        rmSync(stagingDir, { recursive: true, force: true });
+    }
+};
+
 const buildPayload = async (
     options: DeployOptions,
     settings: DeploySettings,
     targets: DeployTarget[],
+    project: CatalogProject | null,
 ): Promise<DeployPayload> => {
-    const metadata = renderMetadata(settings);
-    validateMetadata(settings, metadata, isFlathubSubmission(settings, targets));
+    const templates = renderMetadata(settings);
 
     if (!options.shouldSkipBuild) {
         info(`Building ${options.entry}`);
-        await buildApp({ entry: options.entry, vite: { root: options.cwd } });
+
+        await buildApp({
+            entry: options.entry,
+            vite: { root: options.cwd },
+        });
+
+        await synchronizeMetadataCatalogs(settings, templates, project);
+    } else if (project !== null) {
+        compileCatalogs(project, join(settings.paths.dist, LOCALE_DIRNAME));
     }
 
+    const metadata = localizeMetadata(templates, project);
+    validateMetadata(settings, metadata, isFlathubSubmission(settings, targets));
     const buildManifest = readBuildManifest(settings);
 
     const builtSettings: DeploySettings = {
@@ -262,7 +361,7 @@ const buildPayload = async (
         node,
         stage,
         notices,
-        overlays: stageOverlays(builtSettings, notices),
+        overlays: stageOverlays(builtSettings, notices, metadata),
     };
 };
 
@@ -312,15 +411,31 @@ const announce = (settings: DeploySettings, targets: DeployTarget[]): void => {
 };
 
 const runDeploy = async (options: DeployOptions): Promise<void> => {
+    let settings = await loadSettings(options);
+    let project = resolveCatalogProject(settings.paths.root, settings.applicationId);
+    let targets = targetsFor(resolveTargetNames(options, settings));
+    announce(settings, targets);
+
+    preflight({
+        targets,
+        settings,
+        project,
+        shouldPrintManifests: options.shouldPrintManifests,
+        shouldSkipBuild: options.shouldSkipBuild,
+    });
+
     if (!options.shouldSkipBuild) {
-        await ensureGenerated(options.cwd, { shouldAnnounce: true, mode: BUILD_MODE });
+        await ensureGenerated(options.cwd, {
+            shouldAnnounce: true,
+            mode: BUILD_MODE,
+        });
+
+        settings = await loadSettings(options);
+        project = resolveCatalogProject(settings.paths.root, settings.applicationId);
+        targets = targetsFor(resolveTargetNames(options, settings));
     }
 
-    const settings = await loadSettings(options);
-    const targets = targetsFor(resolveTargetNames(options, settings));
-    announce(settings, targets);
-    preflight(targets, settings, options.shouldPrintManifests);
-    const payload = await buildPayload(options, settings, targets);
+    const payload = await buildPayload(options, settings, targets, project);
     const rendered = renderTargetManifests(targets, payload);
 
     if (options.shouldPrintManifests) {

package/src/deploy/targets/flatpak-source.ts

@@ -1,12 +1,10 @@
-import { existsSync, realpathSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { posix, relative, resolve } from "node:path";
 import type { DeployPayload, DeploySettings } from "../types.js";
+import { LOCALE_DIRNAME } from "../../i18n/catalogs.js";
 import { listFilesRecursive } from "../../internal/list-files.js";
 import { BUNDLE_FILENAME } from "../../vite-plugins/esm-extension.js";
 import { renderDbusService } from "../freedesktop/dbus-service.js";
-import { renderDesktopEntry } from "../freedesktop/desktop-entry.js";
-import { renderMetainfo } from "../freedesktop/metainfo.js";
-import { renderMimePackage } from "../freedesktop/mime-package.js";
 import { optional } from "../nfpm/optional.js";
 import { renderNotices } from "../notices/render.js";
 import { executableModeFor } from "../payload/copy-tree.js";
@@ -60,6 +58,7 @@ const installCommand = (source: string, destination: string, mode: string): stri
 
 const runtimeInstallCommands = (settings: DeploySettings, nodeExtensionPath: string): string[] => {
     const lib = `${DESTINATION}/lib/${settings.binaryName}`;
+    const locale = `${DESTINATION}/share/${LOCALE_DIRNAME}`;
 
     return [
         installCommand(`${nodeExtensionPath}/bin/node`, `${lib}/node`, "m755"),
@@ -69,6 +68,7 @@ const runtimeInstallCommands = (settings: DeploySettings, nodeExtensionPath: str
         "test ! -f dist/gschemas.compiled || " +
         installCommand("dist/gschemas.compiled", `${lib}/gschemas.compiled`, "m644"),
         `test ! -d dist/assets || cp -a dist/assets ${lib}/assets`,
+        `test ! -d dist/${LOCALE_DIRNAME} || { mkdir -p ${locale} && cp -a dist/${LOCALE_DIRNAME}/. ${locale}/; }`,
         installCommand(LAUNCHER_FILENAME, `${DESTINATION}/bin/${settings.binaryName}`, "m755"),
     ];
 };
@@ -87,10 +87,35 @@ const activationInstallCommands = (settings: DeploySettings): string[] =>
             )]
         : [];
 
-const mimeSources = (settings: DeploySettings): FlatpakModule[] => {
-    const contents = renderMimePackage(settings);
+const stagedContents = (payload: DeployPayload, destination: string): string => {
+    const file = payload.stage.find((candidate) => candidate.rel === destination);
 
-    return contents === null ? [] : [inlineSource(`${settings.applicationId}.xml`, contents)];
+    if (file === undefined) {
+        throw new Error(`Cannot render the source Flatpak: ${destination} was not staged`);
+    }
+
+    return readFileSync(file.abs, "utf8");
+};
+
+const stagedMetadataSources = (payload: DeployPayload): FlatpakModule[] => {
+    const settings = payload.settings;
+
+    return [
+        inlineSource(
+            `${settings.applicationId}.desktop`,
+            stagedContents(payload, posix.join("share", "applications", `${settings.applicationId}.desktop`)),
+        ),
+        inlineSource(
+            `${settings.applicationId}.metainfo.xml`,
+            stagedContents(payload, posix.join("share", "metainfo", `${settings.applicationId}.metainfo.xml`)),
+        ),
+        ...(settings.fileAssociations.length === 0
+            ? []
+            : [inlineSource(
+                    `${settings.applicationId}.xml`,
+                    stagedContents(payload, posix.join("share", "mime", "packages", `${settings.applicationId}.xml`)),
+                )]),
+    ];
 };
 
 const mimeInstallCommands = (settings: DeploySettings): string[] =>
@@ -239,9 +264,7 @@ const flatpakSourceModule = (payload: DeployPayload): FlatpakModule => {
             resolveGitSource(settings),
             ...(pin === null ? [] : pnpmSources(pin, moduleDirFor(settings))),
             GENERATED_SOURCES,
-            inlineSource(`${settings.applicationId}.desktop`, renderDesktopEntry(settings)),
-            inlineSource(`${settings.applicationId}.metainfo.xml`, renderMetainfo(settings)),
-            ...mimeSources(settings),
+            ...stagedMetadataSources(payload),
             inlineSource(LAUNCHER_FILENAME, renderLauncher(settings)),
             inlineSource(NOTICES_FILENAME, renderNotices(settings, payload.notices)),
             ...activationSource(settings),

package/src/deploy/tools.ts

@@ -56,6 +56,36 @@ const FLATPAK_NODE_GENERATOR_PNPM: DeployTool = {
     isPresent: () => hasGeneratorPnpmSupport(),
 };
 
+const MSGFMT: DeployTool = {
+    command: "msgfmt",
+    purpose: "compiles the gettext catalogs and localized metadata",
+    isOptional: false,
+};
+
+const MSGGREP: DeployTool = {
+    command: "msggrep",
+    purpose: "retains generated metadata while refreshing the catalog template",
+    isOptional: false,
+};
+
+const MSGINIT: DeployTool = {
+    command: "msginit",
+    purpose: "initializes newly listed gettext catalogs",
+    isOptional: false,
+};
+
+const MSGMERGE: DeployTool = {
+    command: "msgmerge",
+    purpose: "synchronizes translations with the catalog template",
+    isOptional: false,
+};
+
+const XGETTEXT: DeployTool = {
+    command: "xgettext",
+    purpose: "extracts the gettext catalog template",
+    isOptional: false,
+};
+
 const STRIP: DeployTool = {
     command: "strip",
     purpose: "would shrink the bundled Node.js by removing its symbols",
@@ -149,8 +179,13 @@ export {
     FILE_TOOL,
     FLATPAK,
     FLATPAK_BUILDER,
+    MSGFMT,
+    MSGGREP,
+    MSGINIT,
+    MSGMERGE,
     probeTools,
     STRIP,
     TAR,
     warnMissingOptional,
+    XGETTEXT,
 };

package/src/dev/locale-dir.ts

@@ -0,0 +1,22 @@
+import { compileCatalogs, resolveCatalogProject, synchronizeCatalogs } from "../i18n/catalogs.js";
+import { createRetainedStagingDir } from "../internal/staging-dir.js";
+
+const LOCALE_DIR_ENV = "GTKX_LOCALE_DIR";
+const localeDir = createRetainedStagingDir("locale");
+
+const prepareDevLocaleDir = (root: string, domain: string): string | null => {
+    const project = resolveCatalogProject(root, domain);
+
+    if (project === null) {
+        return null;
+    }
+
+    const outputDir = localeDir.retain();
+    synchronizeCatalogs(project);
+    compileCatalogs(project, outputDir);
+    process.env[LOCALE_DIR_ENV] = outputDir;
+
+    return outputDir;
+};
+
+export { prepareDevLocaleDir };

package/src/dev/runner-main.ts

@@ -3,6 +3,7 @@ import { error } from "@gtkx/utils";
 import { resolve } from "node:path";
 import { DEV_ENTRY_ENV } from "./entry-env.js";
 import { prepareDevIconDir } from "./icon-dir.js";
+import { prepareDevLocaleDir } from "./locale-dir.js";
 import { createDevRunner } from "./runner.js";
 import { prepareDevSchemaDir } from "./schema-dir.js";
 
@@ -22,6 +23,7 @@ const main = async (): Promise<void> => {
     }
 
     const { config, root } = await loadConfig(cwd, { mode: "development" });
+    prepareDevLocaleDir(root, config.applicationId);
     prepareDevSchemaDir(root, config.future?.v2ResourceImports === true);
     prepareDevIconDir(root, config.applicationId, config.applicationIcon);
     const entryPath = resolve(cwd, entryArg);