@adminforth/i18n 2.3.2 → 2.5.0

package/dist/index.js

@@ -7,7 +7,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { AdminForthPlugin, Filters, suggestIfTypo, AdminForthDataTypes, RAMLock, filtersTools, AdminForthFilterOperators } from "adminforth";
+import { Filters, suggestIfTypo, AdminForthDataTypes, RAMLock, filtersTools, AdminForthFilterOperators } from "adminforth";
+import { I18nBase, getCountryCodeFromLangCode, getPrimaryLanguageCode, requiresSlavicPlurals, SLAVIC_PLURAL_EXAMPLES, SLAVIC_PLURAL_FORMS, SLAVIC_PLURAL_FORMS_HINT, SOURCE_LANGUAGE } from './base.js';
 import { z } from "zod";
 import iso6391 from 'iso-639-1';
 const updateFieldBodySchema = z.object({
@@ -28,61 +29,10 @@ import path from 'path';
 import fs from 'fs-extra';
 import chokidar from 'chokidar';
 import { AsyncQueue } from '@sapphire/async-queue';
-import getFlagEmoji from 'country-flag-svg';
 import { parse } from 'bcp-47';
 import pLimit from 'p-limit';
 import { afLogger } from "adminforth";
 const processFrontendMessagesQueue = new AsyncQueue();
-const SLAVIC_PLURAL_EXAMPLES = {
-    uk: 'яблук | Яблуко | Яблука | Яблук', // zero | singular | 2-4 | 5+
-    bg: 'ябълки | ябълка | ябълки | ябълки', // zero | singular | 2-4 | 5+
-    cs: 'jablek | jablko | jablka | jablek', // zero | singular | 2-4 | 5+
-    hr: 'jabuka | jabuka | jabuke | jabuka', // zero | singular | 2-4 | 5+
-    mk: 'јаболка | јаболко | јаболка | јаболка', // zero | singular | 2-4 | 5+
-    pl: 'jabłek | jabłko | jabłka | jabłek', // zero | singular | 2-4 | 5+
-    sk: 'jabĺk | jablko | jablká | jabĺk', // zero | singular | 2-4 | 5+
-    sl: 'jabolk | jabolko | jabolka | jabolk', // zero | singular | 2-4 | 5+
-    sr: 'јабука | јабука | јабуке | јабука', // zero | singular | 2-4 | 5+
-    be: 'яблыкаў | яблык | яблыкі | яблыкаў', // zero | singular | 2-4 | 5+
-    ru: 'яблок | яблоко | яблока | яблок', // zero | singular | 2-4 | 5+
-};
-const countryISO31661ByLangISO6391 = {
-    en: 'us', // English → United States
-    zh: 'cn', // Chinese → China
-    hi: 'in', // Hindi → India
-    ar: 'sa', // Arabic → Saudi Arabia
-    ko: 'kr', // Korean → South Korea
-    ja: 'jp', // Japanese → Japan
-    uk: 'ua', // Ukrainian → Ukraine
-    ur: 'pk', // Urdu → Pakistan
-    sr: 'rs', // Serbian → Serbia
-    da: 'dk' // Danish → Denmark
-};
-function getCountryCodeFromLangCode(lang) {
-    const [langCode, region] = String(lang).split('-');
-    if (region && /^[A-Z]{2}$/.test(region)) {
-        return region.toLowerCase();
-    }
-    return countryISO31661ByLangISO6391[langCode] || langCode;
-}
-function getPrimaryLanguageCode(langCode) {
-    return String(langCode).split('-')[0];
-}
-function isValidSupportedLanguageTag(langCode) {
-    try {
-        const schema = parse(String(langCode), {
-            normalize: true,
-            warning: (reason, code, offset) => {
-                console.warn(`Warning in validating language tag ${langCode}: reason=${reason}, code=${code}, offset=${offset}`);
-            }
-        });
-        const isValid = schema.language.length === 2;
-        return isValid;
-    }
-    catch (e) {
-        return false;
-    }
-}
 class CachingAdapterMemory {
     constructor() {
         this.cache = {};
@@ -121,29 +71,30 @@ class AiTranslateError extends Error {
         this.name = 'AiTranslateError';
     }
 }
-export default class I18nPlugin extends AdminForthPlugin {
+export default class I18nPlugin extends I18nBase {
     constructor(options) {
-        super(options, import.meta.url);
-        this.options = options;
+        super(options);
         this.cache = new CachingAdapterMemory();
         this.trFieldNames = {};
-        this.primaryLanguage = options.primaryLanguage || 'en';
+    }
+    // translated languages joined by '|', e.g. 'uk|ja', stored in completedFieldName to filter not fully translated strings
+    completedLangsValue(isTranslated) {
+        return this.targetLanguages().filter(isTranslated).join('|');
     }
     computeCompletedFieldValue(record) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.options.supportedLanguages.reduce((acc, lang) => {
-                if (lang === 'en') {
-                    return acc;
-                }
-                if (record[this.trFieldNames[lang]]) {
-                    if (acc !== '') {
-                        acc += '|';
-                    }
-                    acc += lang;
-                }
-                return acc;
-            }, '');
-        });
+        return this.completedLangsValue((lang) => Boolean(record[this.trFieldNames[lang]]));
+    }
+    // all translations of category for frontend_messages
+    categoryCacheKey(category, lang) {
+        return `${this.resourceConfig.resourceId}:${category}:${lang}`;
+    }
+    // one string translated by backend tr
+    messageCacheKey(category, lang, enString) {
+        return `${this.categoryCacheKey(category, lang)}:${enString}`;
+    }
+    clearTranslationCache(category, lang, enString) {
+        this.cache.clear(this.categoryCacheKey(category, lang));
+        this.cache.clear(this.messageCacheKey(category, lang, enString));
     }
     updateUntranslatedMenuBadge() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -169,12 +120,6 @@ export default class I18nPlugin extends AdminForthPlugin {
             this.adminforth.config.componentsToExplicitRegister.push({
                 file: this.componentPath('TranslationJobViewComponent.vue')
             });
-            // validate each supported language: ISO 639-1 or BCP-47 with region (e.g., en-GB)
-            this.options.supportedLanguages.forEach((lang) => {
-                if (!isValidSupportedLanguageTag(lang)) {
-                    throw new Error(`Invalid language code ${lang}. Use ISO 639-1 (e.g., 'en') or BCP-47 with region (e.g., 'en-GB').`);
-                }
-            });
             if (this.options.translateLangAsBCP47Code) {
                 for (const [lang, bcp47] of Object.entries(this.options.translateLangAsBCP47Code)) {
                     if (!this.options.supportedLanguages.includes(lang)) {
@@ -189,10 +134,7 @@ export default class I18nPlugin extends AdminForthPlugin {
                 throw new Error(`Primary key field not found in resource ${resourceConfig.resourceId}`);
             }
             // parse trFieldNames
-            for (const lang of this.options.supportedLanguages) {
-                if (lang === 'en') {
-                    continue;
-                }
+            for (const lang of this.targetLanguages()) {
                 if ((_b = this.options.translationFieldNames) === null || _b === void 0 ? void 0 : _b[lang]) {
                     this.trFieldNames[lang] = this.options.translationFieldNames[lang];
                 }
@@ -224,17 +166,8 @@ export default class I18nPlugin extends AdminForthPlugin {
                     },
                 };
             }
-            this.enFieldName = this.trFieldNames['en'] || 'en_string';
-            this.fullCompleatedFieldValue = this.options.supportedLanguages.reduce((acc, lang) => {
-                if (lang === 'en') {
-                    return acc;
-                }
-                if (acc !== '') {
-                    acc += '|';
-                }
-                acc += lang;
-                return acc;
-            }, '');
+            this.enFieldName = this.trFieldNames[SOURCE_LANGUAGE] || `${SOURCE_LANGUAGE}_string`;
+            this.fullCompleatedFieldValue = this.completedLangsValue(() => true);
             // if not enFieldName column is not found, throw error
             const enColumn = resourceConfig.columns.find(c => c.name === this.enFieldName);
             if (!enColumn) {
@@ -293,40 +226,15 @@ export default class I18nPlugin extends AdminForthPlugin {
                     type: AdminForthDataTypes.BOOLEAN,
                 });
             }
-            const compMeta = {
-                brandSlug: adminforth.config.customization.brandNameSlug,
-                pluginInstanceId: this.pluginInstanceId,
-                primaryLanguage: this.primaryLanguage,
-                afOrder: this.options.loginPageLanguageSelectorOrder || 0,
-                supportedLanguages: this.options.supportedLanguages.map(lang => ({
-                    code: lang,
-                    // lang name on on language native name
-                    name: iso6391.getNativeName(getPrimaryLanguageCode(lang)),
-                }))
-            };
             // add underLogin component
             if (!this.externalAppOnly) {
-                adminforth.config.customization.loginPageInjections.underLoginButton.push({
-                    file: this.componentPath('LanguageUnderLogin.vue'),
-                    meta: compMeta
-                });
-                (adminforth.config.customization.globalInjections.userMenu).push({
-                    file: this.componentPath('LanguageInUserMenu.vue'),
-                    meta: compMeta
-                });
-                adminforth.config.customization.globalInjections.everyPageBottom.push({
-                    file: this.componentPath('LanguageEveryPageLoader.vue'),
-                    meta: compMeta
-                });
+                this.injectLanguageSelectors(adminforth);
             }
             // disable create allowedActions for translations
             resourceConfig.options.allowedActions.create = false;
             // add hook to validate user did not screw up with template params
             resourceConfig.hooks.edit.beforeSave.push((_a) => __awaiter(this, [_a], void 0, function* ({ updates, oldRecord }) {
-                for (const lang of this.options.supportedLanguages) {
-                    if (lang === 'en') {
-                        continue;
-                    }
+                for (const lang of this.targetLanguages()) {
                     if (updates[this.trFieldNames[lang]]) { // if user set '', it will have '' in updates, then it is fine, we shoudl nto check it
                         if (!ensureTemplateHasAllParams(oldRecord[this.enFieldName], updates[this.trFieldNames[lang]])) {
                             return { ok: false, error: `Template params mismatch for ${updates[this.enFieldName]}. Template param names should be the same as in original string. E. g. 'Hello {name}', should be 'Hola {name}' and not 'Hola {nombre}'!` };
@@ -339,19 +247,10 @@ export default class I18nPlugin extends AdminForthPlugin {
             resourceConfig.hooks.edit.afterSave.push((_a) => __awaiter(this, [_a], void 0, function* ({ updates, oldRecord }) {
                 if (oldRecord) {
                     // find lang which changed
-                    let langsChanged = [];
-                    for (const lang of this.options.supportedLanguages) {
-                        if (lang === 'en') {
-                            continue;
-                        }
-                        if (updates[this.trFieldNames[lang]] !== undefined) {
-                            langsChanged.push(lang);
-                        }
-                    }
+                    const langsChanged = this.targetLanguages().filter((lang) => updates[this.trFieldNames[lang]] !== undefined);
                     // clear frontend cache for all langsChanged
                     for (const lang of langsChanged) {
-                        this.cache.clear(`${this.resourceConfig.resourceId}:${oldRecord[this.options.categoryFieldName]}:${lang}`);
-                        this.cache.clear(`${this.resourceConfig.resourceId}:${oldRecord[this.options.categoryFieldName]}:${lang}:${oldRecord[this.enFieldName]}`);
+                        this.clearTranslationCache(oldRecord[this.options.categoryFieldName], lang, oldRecord[this.enFieldName]);
                     }
                     this.updateUntranslatedMenuBadge();
                 }
@@ -361,9 +260,7 @@ export default class I18nPlugin extends AdminForthPlugin {
             // add hook on delete of any translation to reset cache
             resourceConfig.hooks.delete.afterSave.push((_a) => __awaiter(this, [_a], void 0, function* ({ record }) {
                 for (const lang of this.options.supportedLanguages) {
-                    // if frontend, clear frontend cache
-                    this.cache.clear(`${this.resourceConfig.resourceId}:${record[this.options.categoryFieldName]}:${lang}`);
-                    this.cache.clear(`${this.resourceConfig.resourceId}:${record[this.options.categoryFieldName]}:${lang}:${record[this.enFieldName]}`);
+                    this.clearTranslationCache(record[this.options.categoryFieldName], lang, record[this.enFieldName]);
                 }
                 this.updateUntranslatedMenuBadge();
                 return { ok: true };
@@ -422,6 +319,7 @@ export default class I18nPlugin extends AdminForthPlugin {
                 file: this.componentPath('BulkActionButton.vue'),
                 meta: {
                     supportedLanguages: this.options.supportedLanguages,
+                    countryCodes: Object.fromEntries(this.options.supportedLanguages.map((lang) => [lang, getCountryCodeFromLangCode(lang)])),
                     pluginInstanceId: this.pluginInstanceId,
                 }
             };
@@ -568,13 +466,8 @@ export default class I18nPlugin extends AdminForthPlugin {
                 yield this.adminforth.resource(this.resourceConfig.resourceId).update(strId, Object.assign(Object.assign({}, updates), { [this.options.completedFieldName]: futureCompletedFieldValue }));
             })));
             for (const lang of langsInvolved) {
-                const categoriesInvolved = new Set();
                 for (const { enStr, category } of Object.values(updateStrings)) {
-                    categoriesInvolved.add(category);
-                    yield this.cache.clear(`${this.resourceConfig.resourceId}:${category}:${lang}:${enStr}`);
-                }
-                for (const category of categoriesInvolved) {
-                    yield this.cache.clear(`${this.resourceConfig.resourceId}:${category}:${lang}`);
+                    this.clearTranslationCache(category, lang, enStr);
                 }
             }
             return { ok: true };
@@ -628,14 +521,14 @@ export default class I18nPlugin extends AdminForthPlugin {
             const lang = langIsoCode;
             const primaryLang = getPrimaryLanguageCode(lang);
             const langName = iso6391.getName(primaryLang);
-            const requestSlavicPlurals = Object.keys(SLAVIC_PLURAL_EXAMPLES).includes(primaryLang) && plurals;
+            const requestSlavicPlurals = requiresSlavicPlurals(lang) && plurals;
             const region = langSchema.region;
             const basePrompt = `
       I need to translate strings in JSON to ${langName} language ${replacedLanguageCodeForTranslations || lang.length > 2 ? `BCP-47 code ${langCode}` : `ISO 639-1 code ${langIsoCode}`} from English for my web app.
 
       
       ${region ? `Use the regional conventions for ${langCode} (region ${region}), including spelling, punctuation, and formatting.` : ''}
-      ${requestSlavicPlurals ? `You should provide 4 slavic forms (in format "zero count | singular count | 2-4 | 5+") e.g. "apple | apples" should become "${SLAVIC_PLURAL_EXAMPLES[lang]}"` : ''}
+      ${requestSlavicPlurals ? `You should provide ${SLAVIC_PLURAL_FORMS} slavic forms (in format "${SLAVIC_PLURAL_FORMS_HINT}") e.g. "apple | apples" should become "${SLAVIC_PLURAL_EXAMPLES[primaryLang]}"` : ''}
       JSON keys are internal identifiers. Keep keys as is and write translations into values. If values have variables (in curly brackets), then translated strings should have them as well (variables itself should not be translated). Here are the strings:
       \`\`\`json
       {
@@ -702,6 +595,7 @@ export default class I18nPlugin extends AdminForthPlugin {
                         translations: translations.filter(t => stringBanchCopy.includes(t.en_string)),
                         updateStrings,
                         lang,
+                        countryCode: getCountryCodeFromLangCode(lang),
                         failedToTranslate,
                         needToTranslateByLang,
                         promptCost: basePromptTokenLength + banchTokens,
@@ -718,8 +612,8 @@ export default class I18nPlugin extends AdminForthPlugin {
             const translations = yield this.adminforth.resource(this.resourceConfig.resourceId).list(Filters.IN(this.primaryKeyFieldName, selectedIds));
             const languagesToProcess = selectedLanguages || this.options.supportedLanguages;
             for (const lang of languagesToProcess) {
-                if (lang === 'en') {
-                    // all strings are in English, no need to translate
+                if (lang === SOURCE_LANGUAGE) {
+                    // all strings are in source language, no need to translate
                     continue;
                 }
                 for (const translation of translations) {
@@ -849,10 +743,7 @@ export default class I18nPlugin extends AdminForthPlugin {
         if (this.options.completeAdapter) {
             this.options.completeAdapter.validate();
         }
-        for (const lang of this.options.supportedLanguages) {
-            if (lang === 'en') {
-                continue;
-            }
+        for (const lang of this.targetLanguages()) {
             const column = resourceConfig.columns.find(c => c.name === this.trFieldNames[lang]);
             if (!column) {
                 throw new Error(`Field ${this.trFieldNames[lang]} not found for storing translation for language ${lang}
@@ -887,134 +778,47 @@ export default class I18nPlugin extends AdminForthPlugin {
         // in this plugin we will use plugin to fill the database with missing language messages
         if (!this.externalAppOnly) {
             this.tryProcessAndWatch(adminforth);
-            adminforth.tr = (msg, category, lang, params, pluralizationNumber) => __awaiter(this, void 0, void 0, function* () {
-                if (!msg) {
-                    return msg;
-                }
+            this.installBackendTranslator(adminforth, (msg, category, lang) => __awaiter(this, void 0, void 0, function* () {
                 if (category === 'frontend') {
                     throw new Error(`Category 'frontend' is reserved for frontend messages, use any other category for backend messages`);
                 }
-                // console.log('🪲tr', msg, category, lang);
-                // if lang is not supported, fallback to primaryLanguage, then to english
-                if (!this.options.supportedLanguages.includes(lang)) {
-                    lang = this.primaryLanguage; // fallback to primary language first
-                    if (!this.options.supportedLanguages.includes(lang)) {
-                        lang = 'en'; // final fallback to english
-                    }
-                }
-                let result;
                 // try to get translation from cache
-                const cacheKey = `${resourceConfig.resourceId}:${category}:${lang}:${msg}`;
+                const cacheKey = this.messageCacheKey(category, lang, msg);
                 const cached = yield this.cache.get(cacheKey);
                 if (cached) {
-                    result = cached;
-                }
-                if (!result) {
-                    const resource = adminforth.resource(resourceConfig.resourceId);
-                    const translation = yield resource.get([Filters.EQ(this.enFieldName, msg), Filters.EQ(this.options.categoryFieldName, category)]);
-                    if (!translation) {
-                        yield resource.create({
-                            [this.enFieldName]: msg,
-                            [this.options.categoryFieldName]: category,
-                        });
-                        this.updateUntranslatedMenuBadge();
-                    }
-                    // do this check here, to faster register missing translations
-                    // also not cache it - no sense to cache english strings
-                    if (lang === 'en') {
-                        // set to cache to return faster next time
-                        result = msg;
-                    }
-                    else {
-                        result = translation === null || translation === void 0 ? void 0 : translation[this.trFieldNames[lang]];
-                        if (!result) {
-                            // return english
-                            result = msg;
-                        }
-                    }
-                    // cache so even if key does not exist, we will not hit database
-                    yield this.cache.set(cacheKey, result);
-                }
-                // if msg has '|' in it, then we need to aplly pluralization
-                if (msg.includes('|') && pluralizationNumber !== undefined) {
-                    result = this.applyPluralization(result, pluralizationNumber, lang);
-                }
-                if (params) {
-                    for (const [key, value] of Object.entries(params)) {
-                        if (result) {
-                            result = result.replace(`{${key}}`, value);
-                        }
-                    }
+                    return cached;
+                }
+                const resource = adminforth.resource(resourceConfig.resourceId);
+                const translation = yield resource.get([Filters.EQ(this.enFieldName, msg), Filters.EQ(this.options.categoryFieldName, category)]);
+                if (!translation) {
+                    yield resource.create({
+                        [this.enFieldName]: msg,
+                        [this.options.categoryFieldName]: category,
+                    });
+                    this.updateUntranslatedMenuBadge();
                 }
+                // do this check here, to faster register missing translations
+                const result = lang === SOURCE_LANGUAGE ? msg : (translation === null || translation === void 0 ? void 0 : translation[this.trFieldNames[lang]]) || msg;
+                // cache so even if key does not exist, we will not hit database
+                yield this.cache.set(cacheKey, result);
                 return result;
-            });
-        }
-    }
-    applyPluralization(str, number, lang) {
-        const choices = str.split('|');
-        const choicesLength = choices.length;
-        if (choicesLength > 2) {
-            // this is slavic pluralization
-            return choices[this.slavicPluralRule(number, choicesLength)];
-        }
-        else {
-            return number === 1 ? choices[0] : choices[1];
-        }
-    }
-    // taken from here https://vue-i18n.intlify.dev/guide/essentials/pluralization.html#custom-pluralization
-    slavicPluralRule(choice, choicesLength) {
-        if (choice === 0) {
-            return 0;
-        }
-        const teen = choice > 10 && choice < 20;
-        const endsWithOne = choice % 10 === 1;
-        if (!teen && endsWithOne) {
-            return 1;
-        }
-        if (!teen && choice % 10 >= 2 && choice % 10 <= 4) {
-            return 2;
+            }));
         }
-        return choicesLength < 4 ? 2 : 3;
-    }
-    instanceUniqueRepresentation(pluginOptions) {
-        // optional method to return unique string representation of plugin instance. 
-        // Needed if plugin can have multiple instances on one resource 
-        return `single`;
     }
     getCategoryTranslations(category, lang) {
         return __awaiter(this, void 0, void 0, function* () {
             const resource = this.adminforth.resource(this.resourceConfig.resourceId);
-            const cacheKey = `${this.resourceConfig.resourceId}:${category}:${lang}`;
+            const cacheKey = this.categoryCacheKey(category, lang);
             const cached = yield this.cache.get(cacheKey);
             if (cached) {
                 return cached;
             }
-            const translations = {};
             const allTranslations = yield resource.list([Filters.EQ(this.options.categoryFieldName, category)]);
-            for (const tr of allTranslations) {
-                const translatedValue = tr[this.trFieldNames[lang]];
-                translations[tr[this.enFieldName]] = translatedValue || tr[this.enFieldName];
-            }
+            const translations = this.fallbackToOriginal(Object.fromEntries(allTranslations.map((tr) => [tr[this.enFieldName], tr[this.trFieldNames[lang]]])));
             yield this.cache.set(cacheKey, translations);
             return translations;
         });
     }
-    languagesList() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return Promise.all(this.options.supportedLanguages.map((lang) => __awaiter(this, void 0, void 0, function* () {
-                const flagEmoji = typeof getFlagEmoji === 'function'
-                    ? getFlagEmoji
-                    : getFlagEmoji.default;
-                return {
-                    code: lang,
-                    nameOnNative: iso6391.getNativeName(getPrimaryLanguageCode(lang)),
-                    nameEnglish: iso6391.getName(getPrimaryLanguageCode(lang)),
-                    emojiFlag: getCountryCodeFromLangCode(lang).toUpperCase().replace(/./g, char => String.fromCodePoint(char.charCodeAt(0) + 127397)),
-                    svgFlagB64: yield flagEmoji(getCountryCodeFromLangCode(lang)),
-                };
-            })));
-        });
-    }
     feedCategoryTranslations(messages, category) {
         return __awaiter(this, void 0, void 0, function* () {
             const adminforth = this.adminforth;
@@ -1049,17 +853,7 @@ export default class I18nPlugin extends AdminForthPlugin {
         });
     }
     setupEndpoints(server) {
-        server.endpoint({
-            method: 'GET',
-            path: `/plugin/${this.pluginInstanceId}/frontend_messages`,
-            noAuth: true,
-            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ query }) {
-                const lang = query.lang;
-                // form map of translations
-                const translations = yield this.getCategoryTranslations('frontend', lang);
-                return translations;
-            })
-        });
+        super.setupEndpoints(server);
         const lock = new RAMLock();
         server.endpoint({
             method: 'POST',
@@ -1203,3 +997,4 @@ export default class I18nPlugin extends AdminForthPlugin {
         });
     }
 }
+export { I18nBase, getCountryCodeFromLangCode, getPrimaryLanguageCode, isValidSupportedLanguageTag, requiresSlavicPlurals, SOURCE_LANGUAGE, PLURAL_SEPARATOR, SLAVIC_PLURAL_FORMS, SLAVIC_PLURAL_FORMS_HINT } from './base.js';

package/dist/types.d.ts

@@ -5,8 +5,24 @@ import { type PluginsCommonOptions } from "adminforth";
 type Alpha2Code = keyof typeof iso31661Alpha2ToAlpha3;
 type Bcp47LanguageTag = `${LanguageCode}-${Alpha2Code}`;
 export type SupportedLanguage = LanguageCode | Bcp47LanguageTag;
-export interface PluginOptions extends PluginsCommonOptions {
+/**
+ * Options shared by all i18n plugins built on top of I18nBase
+ */
+export interface I18nBaseOptions extends PluginsCommonOptions {
     supportedLanguages: SupportedLanguage[];
+    /**
+     * Language selector on login page order
+     */
+    loginPageLanguageSelectorOrder?: number;
+    /**
+     * Primary language for the application. This is the default language shown to users.
+     * English is always used as the source language for translations, even if primaryLanguage is different.
+     * When a translation is missing for the primaryLanguage, English will be shown as fallback.
+     * Defaults to 'en' if not specified.
+     */
+    primaryLanguage?: SupportedLanguage;
+}
+export interface PluginOptions extends I18nBaseOptions {
     /**
      * Each translation string will be stored in a separate field, you can remap it to existing columns  using this option
      * By default it will assume field are named like `${lang_code}_string` (e.g. 'en_string', 'uk_string', 'ja_string', 'fr_string')
@@ -18,10 +34,6 @@ export interface PluginOptions extends PluginsCommonOptions {
      * We recommend to put index on this column
      */
     categoryFieldName: string;
-    /**
-     * Language selector on login page order
-     */
-    loginPageLanguageSelectorOrder?: number;
     /**
      * Optional source field to store e.g. file name where it first was captured
      */
@@ -46,13 +58,6 @@ export interface PluginOptions extends PluginsCommonOptions {
      * it should be a JSON field (underlyng database type should be TEXT or JSON)
      */
     reviewedCheckboxesFieldName?: string;
-    /**
-     * Primary language for the application. This is the default language shown to users.
-     * English is always used as the source language for translations, even if primaryLanguage is different.
-     * When a translation is missing for the primaryLanguage, English will be shown as fallback.
-     * Defaults to 'en' if not specified.
-     */
-    primaryLanguage?: SupportedLanguage;
     /**
       *  Ask translator to treat some code from supportedLanguages as exact BCP47 tag. Read docs for details.
       *  key - one of the values form supportedLanguages, value -BCP47 tag