@open-xchange/vite-plugin-po2json 1.0.0-pre1

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+This plugin evolved from [@open-xchange/rollup-plugin-po2json](https://gitlab.com/openxchange/appsuite/web-foundation/tools/-/tree/main/packages/rollup-plugin-po2json), adapted for Vite 8 and Rolldown.
+
+## [1.0.0] - 2026-03-13
+
+### Changed
+
+- Fork from `@open-xchange/rollup-plugin-po2json` v0.9.5
+- Migrate to Vite 8 / Rolldown
+- Emit translation chunks in `buildStart` (Rolldown suppresses `resolveDynamicImport` for `@vite-ignore` imports)
+- Set `dictionary: true` in `resolveId` (Rolldown doesn't apply meta from `load` hook)
+- Migrate tests from Rollup to Vite build API
+- Add `vite ^8.0.0` as peer dependency

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 OX Software GmbH, Germany. info@open-xchange.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import type { Plugin } from 'vite';
+import type { POHeaders } from './util/util.js';
+import { PROJECT_NAME } from './util/util.js';
+import { namespacesFrom, parsePoFile } from './lib/po2json.js';
+export { PROJECT_NAME, parsePoFile, namespacesFrom };
+/**
+ * Configuration options for the Vite plugin "vite-plugin-po2json".
+ */
+export interface GettextPluginOptions {
+    poFiles: string;
+    outFile?: string;
+    defaultDictionary?: string;
+    defaultLanguage?: string;
+    headers?: POHeaders;
+    includeFuzzy?: boolean;
+}
+/**
+ * Type shape of the Vite plugin "vite-plugin-po2json".
+ */
+export interface GettextPlugin extends Plugin {
+    /** The resolved configuration options passed to the plugin. */
+    meta: Required<GettextPluginOptions>;
+}
+/**
+ * Type shape of internal module metadata used by the gettext plugin.
+ */
+export interface GettextPluginModuleMeta {
+    gettext?: {
+        dictionary: boolean;
+    };
+}
+export default function gettextPlugin(options: GettextPluginOptions): GettextPlugin;

package/dist/index.js

@@ -0,0 +1,167 @@
+import { dataToEsm, normalizePath } from '@rollup/pluginutils';
+import PO from 'pofile';
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { PROJECT_NAME, itemKey, AmbiguousPluralFormException } from './util/util.js';
+import { namespacesFrom, render, parsePoFile } from './lib/po2json.js';
+import { extractItems } from './lib/extract.js';
+export { PROJECT_NAME, parsePoFile, namespacesFrom };
+export default function gettextPlugin(options) {
+    const resolvedOptions = {
+        outFile: 'i18n.pot',
+        defaultDictionary: 'i18n',
+        defaultLanguage: 'en_US',
+        headers: {
+            'Content-Type': 'text/plain; charset=UTF-8',
+            'Content-Transfer-Encoding': '8bit'
+        },
+        includeFuzzy: false,
+        ...options
+    };
+    let resolvedConfig;
+    const { poFiles, outFile, defaultDictionary, defaultLanguage } = resolvedOptions;
+    const dictionaries = new Set([defaultDictionary]);
+    const codeMap = new Map();
+    let extractedPo;
+    return {
+        name: PROJECT_NAME,
+        meta: resolvedOptions,
+        configResolved(config) {
+            resolvedConfig = config;
+        },
+        async buildStart() {
+            const poDir = path.dirname(poFiles);
+            const [file] = (await readdir(poDir)).filter(f => f.indexOf(defaultLanguage) >= 0).map(f => normalizePath(`${poDir}/${f}`));
+            const po = await parsePoFile(file);
+            for (const namespace of namespacesFrom(po.items)) {
+                if (namespace !== defaultDictionary)
+                    dictionaries.add(namespace);
+            }
+            // Emit translation chunks for all dictionaries and languages.
+            // In Rollup this was done in resolveDynamicImport, but Rolldown
+            // suppresses that hook for @vite-ignore dynamic imports.
+            if (resolvedConfig?.mode === 'production') {
+                const files = (await readdir(poDir)).map(f => normalizePath(`${poDir}/${f}`));
+                for (const file of files) {
+                    const language = (file.match(/([^/]+).po$/) || [])[1];
+                    if (!language)
+                        continue;
+                    for (const namespace of dictionaries) {
+                        this.emitFile({
+                            type: 'chunk',
+                            id: `${namespace}.${language}.js`,
+                            fileName: `${namespace}.${language}.js`,
+                            preserveSignature: 'strict'
+                        });
+                    }
+                }
+            }
+        },
+        resolveId(id) {
+            if (/^gettext$/.test(id)) {
+                const meta = { gettext: { dictionary: true } };
+                return { id: `${defaultDictionary}.js`, meta };
+            }
+            const gettextModuleMatch = id.match(/gettext\?.*dictionary=([^&]+)/);
+            if (gettextModuleMatch) {
+                dictionaries.add(gettextModuleMatch[1].replace(/\.js$/, ''));
+                const meta = { gettext: { dictionary: true } };
+                return { id: gettextModuleMatch[1].replace(/(\.js)?$/, '.js'), meta };
+            }
+            if (dictionaries.has(id.replace(/\.js$/, ''))) {
+                const meta = { gettext: { dictionary: true } };
+                return { id, meta };
+            }
+            const match = id.match(/(.*)\.([a-zA-Z]{2}_[a-zA-Z]{2})(\.js)?$/);
+            const [, namespace, language] = match || [];
+            return (namespace && language) ? id : null;
+        },
+        transform: {
+            order: 'pre',
+            handler(code, id) {
+                codeMap.set(id, code);
+            }
+        },
+        async load(id) {
+            const dictionary = id.replace(/\\/g, '/').replace(/^\.?\//, '').replace(/\.js$/, '');
+            if (dictionaries.has(dictionary)) {
+                const poDir = path.dirname(poFiles);
+                const languages = (await readdir(poDir)).map(f => (f.match(/([^/]+).po$/) || [])[1]).filter(a => Boolean(a));
+                const code = (await readFile(new URL('./lib/dictionary.js', import.meta.url))).toString()
+                    .replaceAll('__dict_module__', `${dictionary}.${defaultLanguage}`)
+                    .replaceAll('{{namespace}}', dictionary)
+                    .replaceAll('{{defaultLanguage}}', defaultLanguage)
+                    .replaceAll(/['"]{{languages}}['"]/g, languages.map(lang => `'${lang}'`).join(', '));
+                return { meta: { gettext: { dictionary: true } }, code };
+            }
+            const match = id.match(/\.?\/?(.*)\.([a-zA-Z]{2}_[a-zA-Z]{2})(\.js)?$/);
+            const [, namespace, language] = match || [];
+            if (!namespace || !language || !dictionaries.has(namespace))
+                return;
+            const filename = normalizePath(`${path.dirname(poFiles)}/${language}.po`);
+            const chunk = render(await parsePoFile(filename), options);
+            return dataToEsm(chunk);
+        },
+        buildEnd() {
+            // optimize for vite development mode, no need to do anything on buildEnd (server stop)
+            if (resolvedConfig?.mode === 'development')
+                return;
+            const po = new PO();
+            Object.assign(po.headers, resolvedOptions.headers);
+            const gettextImporters = () => {
+                const importers = new Set();
+                for (const id of this.getModuleIds()) {
+                    const moduleInfo = this.getModuleInfo(id);
+                    if (moduleInfo && moduleInfo.meta.gettext?.dictionary) {
+                        for (const importer of moduleInfo.importers) {
+                            importers.add(importer);
+                        }
+                    }
+                }
+                return importers;
+            };
+            const allItems = new Map();
+            for (const importer of gettextImporters()) {
+                const moduleInfo = this.getModuleInfo(importer);
+                const code = moduleInfo && codeMap.get(moduleInfo.id);
+                if (code) {
+                    for (const [key, msgItem] of extractItems(moduleInfo.id, code)) {
+                        let item = allItems.get(key);
+                        if (!item)
+                            allItems.set(key, item = msgItem);
+                        // add module reference
+                        item.references.push(normalizePath(path.relative(process.cwd(), moduleInfo.id)));
+                        // merge extracted comments
+                        for (const comment of msgItem.extractedComments) {
+                            if (item.extractedComments.filter(c => c === comment).length === 0)
+                                item.extractedComments.push(comment);
+                        }
+                        // merge flags
+                        Object.assign(item.flags, msgItem.flags);
+                    }
+                }
+            }
+            for (const item of allItems.values()) {
+                // detect colliding singular/plural
+                if (item.msgid_plural) {
+                    const collidingItem = allItems.get(itemKey(item, false));
+                    if (collidingItem)
+                        throw new AmbiguousPluralFormException(item, collidingItem);
+                }
+                if (options.defaultDictionary)
+                    item.references.push(`module:${defaultDictionary}`);
+                po.items.push(item);
+            }
+            extractedPo = po;
+        },
+        generateBundle() {
+            const po = extractedPo;
+            this.emitFile({
+                name: outFile,
+                fileName: outFile,
+                type: 'asset',
+                source: po.toString()
+            });
+        }
+    };
+}

package/dist/lib/dictionary.d.ts

@@ -0,0 +1,21 @@
+import type { POHeaders, PODictionary } from '../util/util.js';
+type PluralFn = (n: number) => number;
+export declare class Dictionary {
+    readonly namespace: string;
+    private _headers;
+    dict: PODictionary;
+    plural: PluralFn;
+    constructor(namespace: string, headers: POHeaders, dict: PODictionary);
+    set headers(headers: POHeaders);
+    get headers(): POHeaders;
+    changeLanguage(language: string): Promise<void>;
+    gettext(str: string, ...args: unknown[]): string;
+    pgettext(context: string, str: string, ...args: unknown[]): string;
+    ngettext(singular: string, plural: string, count: number, ...args: unknown[]): string;
+    npgettext(context: string, singular: string, plural: string, count: number, ...args: unknown[]): string;
+    noI18n(a: string): string;
+}
+export declare const dictionary: Dictionary;
+declare function simpleGt(str: string, ...args: unknown[]): string;
+export declare const gt: typeof simpleGt;
+export default gt;

package/dist/lib/dictionary.js

@@ -0,0 +1,92 @@
+import defaultDict, { headers as defaultHeaders } from './__dict_module__';
+function printf(str, params) {
+    let index = 0;
+    return str
+        .replace(/%(([0-9]+)\$)?[A-Za-z]/g, (_match, pos, n) => {
+        if (pos)
+            index = n - 1;
+        const val = params[index++];
+        return val !== undefined ? String(val) : 'unknown';
+    })
+        .replace(/%%/g, '%');
+}
+function parsePluralHeader(header) {
+    const matches = header?.match(/plural=([^;]+)/);
+    return matches ? matches[1] : '(n!=1)';
+}
+const languages = ['{{languages}}'];
+export class Dictionary {
+    namespace;
+    _headers;
+    dict;
+    plural;
+    constructor(namespace, headers, dict) {
+        this.namespace = namespace;
+        this.headers = headers;
+        this.dict = dict;
+    }
+    set headers(headers) {
+        this._headers = headers;
+        const plural = parsePluralHeader(this.headers['Plural-Forms']);
+        // eslint-disable-next-line no-new-func
+        this.plural = new Function('n', `return Number(${plural});`);
+    }
+    get headers() {
+        return this._headers;
+    }
+    async changeLanguage(language) {
+        if (language === this.headers.Language)
+            return;
+        if (!languages.includes(language))
+            throw new Error(`Language not found: ${language} (in ${languages.join(', ')})`);
+        // prevent rollup dynamic import vars plugin from detecting this import
+        // this is only needed in case the plugin is in use, but doesn't hurt
+        let path;
+        try {
+            if (typeof window !== 'undefined' && typeof process === 'undefined' && window.location?.href) {
+                path = new URL(`${this.namespace}.${language}.js`, window.location.href).href;
+            }
+            else {
+                throw new Error('Not in browser');
+            }
+        }
+        catch {
+            path = `./${this.namespace.replace(/.*\//, '')}.${language}.js`;
+        }
+        const { default: dict, headers } = await import(/* @vite-ignore */ path);
+        headers.Language = language;
+        this.headers = headers;
+        this.dict = dict;
+    }
+    gettext(str, ...args) {
+        return this.npgettext('', str, '', 1, ...args);
+    }
+    pgettext(context, str, ...args) {
+        return this.npgettext(context, str, '', 1, ...args);
+    }
+    ngettext(singular, plural, count, ...args) {
+        return this.npgettext('', singular, plural, count, ...args);
+    }
+    npgettext(context, singular, plural, count, ...args) {
+        const translations = this.dict[`${context}\x00${singular}\x01${plural}`] || [];
+        if (translations.length === 0)
+            translations.push(singular, plural);
+        const translation = translations[this.plural(Number(count))] || translations[0];
+        return args.length ? printf(translation, args) : translation;
+    }
+    noI18n(a) {
+        return a;
+    }
+}
+defaultHeaders.Language = '{{defaultLanguage}}';
+export const dictionary = new Dictionary('{{namespace}}', defaultHeaders, defaultDict);
+function simpleGt(str, ...args) {
+    return dictionary.npgettext('', str, '', 1, ...args);
+}
+export const gt = new Proxy(simpleGt, {
+    get(_target, prop) {
+        const value = dictionary[prop];
+        return (typeof value === 'function') ? value.bind(dictionary) : value;
+    }
+});
+export default gt;

package/dist/lib/extract.d.ts

@@ -0,0 +1,2 @@
+import { type POItem } from '../util/util.js';
+export declare function extractItems(id: string, code: string): Map<string, POItem>;

package/dist/lib/extract.js

@@ -0,0 +1,176 @@
+import ts from 'typescript';
+import PO from 'pofile';
+import { itemKey } from '../util/util.js';
+// expected gettext module name in import statements of parsed code
+const IMPORT_MODULE_NAME = 'gettext'; // TODO: make configurable?
+function walk(node, cb) {
+    cb(node);
+    ts.forEachChild(node, child => walk(child, cb));
+}
+function isImportDeclaration(node) {
+    return node.kind === ts.SyntaxKind.ImportDeclaration;
+}
+function isNamedImports(node) {
+    return node.kind === ts.SyntaxKind.NamedImports;
+}
+function isCallExpression(node) {
+    return node.kind === ts.SyntaxKind.CallExpression;
+}
+function isMemberExpression(node) {
+    return node.kind === ts.SyntaxKind.PropertyAccessExpression;
+}
+function isBinaryExpression(node) {
+    return node.kind === ts.SyntaxKind.BinaryExpression;
+}
+function isIdentifier(node) {
+    return node.kind === ts.SyntaxKind.Identifier;
+}
+function isStringLiteral(node) {
+    return node.kind === ts.SyntaxKind.StringLiteral;
+}
+function isString(value) {
+    return typeof value === 'string';
+}
+function getStringLiteral(node) {
+    return isStringLiteral(node) ? node.text : undefined;
+}
+function resolveStringExpression(node) {
+    if (isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+        const leftValue = resolveStringExpression(node.left);
+        const rightValue = getStringLiteral(node.right);
+        return (isString(leftValue) && isString(rightValue)) ? (leftValue + rightValue) : undefined;
+    }
+    return getStringLiteral(node);
+}
+export function extractItems(id, code) {
+    // let TypeScript parse the source code
+    const sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.ESNext);
+    // all comments starting with '#', mapped by line number
+    const comments = new Map();
+    // extracts the text of comments from TS comment ranges
+    function processCommentRanges(commentRanges) {
+        if (commentRanges) {
+            for (const commentRange of commentRanges) {
+                const block = commentRange.kind === ts.SyntaxKind.MultiLineCommentTrivia;
+                const comment = code.slice(commentRange.pos, commentRange.end);
+                const text = comment.replace(block ? /^\/\*|\*\/$/g : /^\/\//, '').trim();
+                if (text.startsWith('#')) {
+                    const { line } = sourceFile.getLineAndCharacterOfPosition(commentRange.pos);
+                    comments.set(line, { text, block });
+                }
+            }
+        }
+    }
+    // names of identifiers used as 'gettext' function names
+    const identifiers = new Set();
+    // the extracted PO items
+    const items = new Map();
+    const mapOfSets = new Map();
+    walk(sourceFile, node => {
+        // collect all comments surrounding the node
+        processCommentRanges(ts.getLeadingCommentRanges(code, node.getFullStart()));
+        processCommentRanges(ts.getTrailingCommentRanges(code, node.pos));
+        // collect all import statements used as 'gt' function
+        if (isImportDeclaration(node)) {
+            // skip side effect or type imports
+            if (node.importClause && !node.importClause.isTypeOnly) {
+                const source = getStringLiteral(node.moduleSpecifier);
+                // module name may be followed by query string
+                if (source === IMPORT_MODULE_NAME || source?.startsWith(IMPORT_MODULE_NAME + '?')) {
+                    // default import
+                    const defaultImport = node.importClause.name;
+                    if (defaultImport && !node.importClause.isTypeOnly)
+                        identifiers.add(defaultImport.text);
+                    // named imports
+                    const bindings = node.importClause.namedBindings;
+                    if (bindings && isNamedImports(bindings)) {
+                        for (const element of bindings.elements) {
+                            if (!element.isTypeOnly)
+                                identifiers.add(element.name.text);
+                        }
+                    }
+                }
+            }
+            return;
+        }
+        if (isCallExpression(node)) {
+            let id;
+            let msgctxt;
+            let msgid;
+            let msgidPlural;
+            const callExpression = node.expression;
+            const argsCount = node.arguments.length;
+            // simple function call, e.g. `gt('string')`
+            if (isIdentifier(callExpression) && argsCount >= 1) {
+                id = callExpression.text;
+                msgid = resolveStringExpression(node.arguments[0]);
+            }
+            // simple member call, e.g. `gt.pgettext('context', 'string')`
+            if (isMemberExpression(callExpression) && isIdentifier(callExpression.expression) && isIdentifier(callExpression.name)) {
+                id = callExpression.expression.text;
+                switch (callExpression.name.text) {
+                    case 'pgettext':
+                        if (argsCount >= 2) {
+                            msgctxt = getStringLiteral(node.arguments[0]);
+                            msgid = resolveStringExpression(node.arguments[1]);
+                        }
+                        break;
+                    case 'ngettext':
+                        if (argsCount >= 2) {
+                            msgid = resolveStringExpression(node.arguments[0]);
+                            msgidPlural = resolveStringExpression(node.arguments[1]);
+                        }
+                        break;
+                    case 'npgettext':
+                        if (argsCount >= 3) {
+                            msgctxt = getStringLiteral(node.arguments[0]);
+                            msgid = resolveStringExpression(node.arguments[1]);
+                            msgidPlural = resolveStringExpression(node.arguments[2]);
+                        }
+                        break;
+                }
+            }
+            if (id && msgid) {
+                const item = new PO.Item();
+                item.msgctxt = msgctxt;
+                item.msgid = msgid;
+                item.msgid_plural = msgidPlural;
+                // extract comments and flags
+                const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line;
+                for (let line = start; true; line--) {
+                    const comment = comments.get(line);
+                    comments.delete(line);
+                    if (!comment && (line === start))
+                        continue; // comment may be missing on same line
+                    if (!comment || (comment.block && line < start))
+                        break; // exit loop if no more line comments available
+                    const marker = comment.text.slice(0, 2);
+                    const text = comment.text.slice(2).trim();
+                    switch (marker) {
+                        case '#.':
+                            item.extractedComments.unshift(text);
+                            break;
+                        case '#,':
+                            item.flags[text] = true;
+                            break;
+                    }
+                }
+                // automatically add 'c-format' flag when using placeholders in the message
+                const regex = /%([idufFgG]|\d+\$)/;
+                if (item.msgid.match(regex) || item.msgid_plural?.match(regex)) {
+                    item.flags['c-format'] = true;
+                }
+                let itemSet = mapOfSets.get(id);
+                if (!itemSet)
+                    mapOfSets.set(id, itemSet = []);
+                itemSet.push(item);
+            }
+        }
+    });
+    identifiers.forEach(id => {
+        mapOfSets.get(id)?.forEach(item => {
+            items.set(itemKey(item), item);
+        });
+    });
+    return items;
+}

package/dist/lib/po2json.d.ts

@@ -0,0 +1,9 @@
+import PO from 'pofile';
+import type { GettextPluginOptions } from '../index.js';
+import type { POHeaders, PODictionary, POItem } from '../util/util.js';
+export type PORenderedChunk = PODictionary & {
+    headers: POHeaders;
+};
+export declare function render(po: PO, { includeFuzzy }: GettextPluginOptions): PORenderedChunk;
+export declare function namespacesFrom(items: POItem[]): string[];
+export declare function parsePoFile(file: string): Promise<PO>;

package/dist/lib/po2json.js

@@ -0,0 +1,35 @@
+import PO from 'pofile';
+import { itemKey } from '../util/util.js';
+function isFuzzy(item) {
+    return !item.flags.fuzzy;
+}
+// test if translations are blank/empty
+function hasTranslation(item) {
+    return item.msgstr.join('').length > 0;
+}
+export function render(po, { includeFuzzy }) {
+    const dict = {};
+    for (const item of po.items) {
+        if ((includeFuzzy || isFuzzy(item)) && !item.obsolete && hasTranslation(item)) {
+            dict[itemKey(item)] = item.msgstr;
+        }
+    }
+    return Object.assign({ headers: po.headers }, dict);
+}
+export function namespacesFrom(items) {
+    const namespaces = new Set();
+    for (const item of items) {
+        for (const reference of item.references) {
+            const matches = reference.match(/module:([^\s]+)/);
+            if (matches) {
+                namespaces.add(matches[1]);
+            }
+        }
+    }
+    return Array.from(namespaces);
+}
+export function parsePoFile(file) {
+    return new Promise((resolve, reject) => {
+        PO.load(file, (err, po) => err ? reject(err) : resolve(po));
+    });
+}

package/dist/util/util.d.ts

@@ -0,0 +1,13 @@
+import type PO from 'pofile';
+export type { PO };
+export type POHeaders = PO['headers'];
+export type PODictionary = Record<string, string[]>;
+export type POItem = InstanceType<typeof PO.Item>;
+export declare const PROJECT_NAME = "gettext";
+export declare function itemKey(item: POItem, plural?: boolean): string;
+export declare class AmbiguousPluralFormException extends Error {
+    readonly poItem: POItem;
+    readonly collidingPoItem: POItem;
+    constructor(poItem: POItem, collidingPoItem: POItem);
+    toString(): string;
+}

package/dist/util/util.js

@@ -0,0 +1,23 @@
+export const PROJECT_NAME = 'gettext';
+export function itemKey(item, plural = true) {
+    return `${item.msgctxt || ''}\x00${item.msgid}\x01${(plural && item.msgid_plural) || ''}`;
+}
+export class AmbiguousPluralFormException extends Error {
+    poItem;
+    collidingPoItem;
+    constructor(poItem, collidingPoItem) {
+        super();
+        this.poItem = poItem;
+        this.collidingPoItem = collidingPoItem;
+        this.message = this.toString();
+    }
+    toString() {
+        return `
+      Usage of singular and plural form of "${this.poItem.msgid}" in the same context:
+      ${(this.collidingPoItem.msgctxt || '[no context]')}
+      \n\nReferences:\n${this.poItem.references.join(', ')}\n
+      \n${this.collidingPoItem.references.join(', ')}
+      \n\nChange the context of at least one of the strings (pgettext) or use ngettext/npgettext in both cases.
+    `;
+    }
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@open-xchange/vite-plugin-po2json",
+  "version": "1.0.0-pre1",
+  "description": "A Vite plugin to load po files into our gettext based dictionary implementation.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/openxchange/appsuite/web-foundation/tools",
+    "directory": "packages/vite-plugin-po2json"
+  },
+  "author": "App Suite Web Foundation <app-suite-web-foundation@open-xchange.com>",
+  "contributors": [
+    "Daniel Rentz <daniel.rentz@open-xchange.com>",
+    "David Bauer <david.bauer@open-xchange.com>",
+    "Julian Bäume <julian.baeume@open-xchange.com>",
+    "Maik Schäfer <maik.schaefer@open-xchange.com>",
+    "Richard Petersen"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@rollup/pluginutils": "^5.3.0",
+    "pofile": "^1.1.4",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "vite": "^8.0.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-dynamic-import-vars": "^2.1.5",
+    "@types/node": "^24.10.3",
+    "cross-env": "^10.1.0",
+    "vite": "^8.0.0",
+    "vitest": "^4.0.15",
+    "@open-xchange/lint": "0.2.1"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "build": "tsc",
+    "dev": "pnpm dlx nodemon --watch src --ext ts --exec tsc",
+    "test": "tsc && vitest"
+  }
+}