@adminforth/i18n 2.3.2 → 2.5.0

package/index.ts

@@ -1,6 +1,7 @@
-import AdminForth, { AdminForthPlugin, Filters, suggestIfTypo, AdminForthDataTypes, RAMLock, filtersTools, AdminForthFilterOperators } from "adminforth";
+import AdminForth, { Filters, suggestIfTypo, AdminForthDataTypes, RAMLock, filtersTools, AdminForthFilterOperators } from "adminforth";
 import type { IAdminForth, IHttpServer, AdminForthComponentDeclaration, AdminForthResourceColumn, AdminForthResource, BeforeLoginConfirmationFunction, AdminForthConfigMenuItem, AdminUser } from "adminforth";
 import type { PluginOptions, SupportedLanguage } from './types.js';
+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';
 
@@ -25,7 +26,6 @@ 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 { randomUUID } from 'crypto';
@@ -33,62 +33,6 @@ 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: SupportedLanguage) {
-  const [langCode, region] = String(lang).split('-');
-  if (region && /^[A-Z]{2}$/.test(region)) {
-    return region.toLowerCase();
-  }
-  return countryISO31661ByLangISO6391[langCode] || langCode;
-}
-
-function getPrimaryLanguageCode(langCode: SupportedLanguage): string {
-  return String(langCode).split('-')[0];
-}
-
-function isValidSupportedLanguageTag(langCode: SupportedLanguage): boolean {
-  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;
-  }
-}
-
 interface IFailedTranslation {
   lang: SupportedLanguage;
   en_string: string;
@@ -134,8 +78,7 @@ class AiTranslateError extends Error {
     this.name = 'AiTranslateError';
   }
 }
-export default class I18nPlugin extends AdminForthPlugin {
-  options: PluginOptions;
+export default class I18nPlugin extends I18nBase<PluginOptions> {
   emailField: AdminForthResourceColumn;
   passwordField: AdminForthResourceColumn;
   authResource: AdminForthResource;
@@ -146,35 +89,39 @@ export default class I18nPlugin extends AdminForthPlugin {
   primaryKeyFieldName: string;
   menuItemWithBadgeId: string;
 
-  adminforth: IAdminForth;
-
   externalAppOnly: boolean;
 
   // sorted by name list of all supported languages, without en e.g. 'al|ro|uk'
   fullCompleatedFieldValue: string;
-  primaryLanguage: SupportedLanguage;
 
   constructor(options: PluginOptions) {
-    super(options, import.meta.url);
-    this.options = options;
+    super(options);
     this.cache = new CachingAdapterMemory();
     this.trFieldNames = {};
-    this.primaryLanguage = options.primaryLanguage || 'en';
   }
 
-  async computeCompletedFieldValue(record: any) {
-    return this.options.supportedLanguages.reduce((acc: string, lang: SupportedLanguage): string => {
-      if (lang === 'en') {
-        return acc;
-      }
-      if (record[this.trFieldNames[lang]]) {
-        if (acc !== '') {
-          acc += '|';
-        }
-        acc += (lang as string);
-      }
-      return acc;
-    }, '');
+  // translated languages joined by '|', e.g. 'uk|ja', stored in completedFieldName to filter not fully translated strings
+  completedLangsValue(isTranslated: (lang: SupportedLanguage) => boolean): string {
+    return this.targetLanguages().filter(isTranslated).join('|');
+  }
+
+  computeCompletedFieldValue(record: any): string {
+    return this.completedLangsValue((lang) => Boolean(record[this.trFieldNames[lang]]));
+  }
+
+  // all translations of category for frontend_messages
+  categoryCacheKey(category: string, lang: string): string {
+    return `${this.resourceConfig.resourceId}:${category}:${lang}`;
+  }
+
+  // one string translated by backend tr
+  messageCacheKey(category: string, lang: string, enString: string): string {
+    return `${this.categoryCacheKey(category, lang)}:${enString}`;
+  }
+
+  clearTranslationCache(category: string, lang: string, enString: string) {
+    this.cache.clear(this.categoryCacheKey(category, lang));
+    this.cache.clear(this.messageCacheKey(category, lang, enString));
   }
 
   async updateUntranslatedMenuBadge() {
@@ -201,13 +148,6 @@ export default class I18nPlugin extends AdminForthPlugin {
       }
     );
 
-    // 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 as SupportedLanguage)) {
@@ -226,10 +166,7 @@ export default class I18nPlugin extends AdminForthPlugin {
     }
 
     // parse trFieldNames
-    for (const lang of this.options.supportedLanguages) {
-      if (lang === 'en') {
-        continue;
-      }
+    for (const lang of this.targetLanguages()) {
       if (this.options.translationFieldNames?.[lang]) {
         this.trFieldNames[lang] = this.options.translationFieldNames[lang];
       } else {
@@ -264,18 +201,9 @@ export default class I18nPlugin extends AdminForthPlugin {
       };
     }
 
-    this.enFieldName = this.trFieldNames['en'] || 'en_string';
+    this.enFieldName = this.trFieldNames[SOURCE_LANGUAGE] || `${SOURCE_LANGUAGE}_string`;
 
-    this.fullCompleatedFieldValue = this.options.supportedLanguages.reduce((acc: string, lang: SupportedLanguage) => {
-      if (lang === 'en') {
-        return acc;
-      }
-      if (acc !== '') {
-        acc += '|';
-      }
-      acc += lang as string;
-      return acc;
-    }, '');
+    this.fullCompleatedFieldValue = this.completedLangsValue(() => true);
 
     // if not enFieldName column is not found, throw error
     const enColumn = resourceConfig.columns.find(c => c.name === this.enFieldName);
@@ -341,35 +269,9 @@ export default class I18nPlugin extends AdminForthPlugin {
       });
     }
 
-    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 as Array<any>).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
@@ -377,10 +279,7 @@ export default class I18nPlugin extends AdminForthPlugin {
 
     // add hook to validate user did not screw up with template params
     resourceConfig.hooks.edit.beforeSave.push(async ({ updates, oldRecord }: { updates: any, oldRecord?: any }): Promise<{ ok: boolean, error?: string }> => {
-      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}'!` };
@@ -394,20 +293,11 @@ export default class I18nPlugin extends AdminForthPlugin {
     resourceConfig.hooks.edit.afterSave.push(async ({ updates, oldRecord }: { updates: any, oldRecord?: any }): Promise<{ ok: boolean, error?: string }> => {
       if (oldRecord) {
         // find lang which changed
-        let langsChanged: SupportedLanguage[] = [];
-        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();
       }
@@ -418,9 +308,7 @@ export default class I18nPlugin extends AdminForthPlugin {
     // add hook on delete of any translation to reset cache
     resourceConfig.hooks.delete.afterSave.push(async ({ record }: { record: any }): Promise<{ ok: boolean, error?: string }> => {
       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 };
@@ -489,6 +377,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,
       }
     }
@@ -671,13 +560,8 @@ export default class I18nPlugin extends AdminForthPlugin {
     
 
     for (const lang of langsInvolved) {
-      const categoriesInvolved = new Set();
       for (const { enStr, category } of Object.values(updateStrings)) {
-        categoriesInvolved.add(category);
-        await this.cache.clear(`${this.resourceConfig.resourceId}:${category}:${lang}:${enStr}`);
-      }
-      for (const category of categoriesInvolved) {
-        await this.cache.clear(`${this.resourceConfig.resourceId}:${category}:${lang}`);
+        this.clearTranslationCache(category, lang, enStr);
       }
     }
 
@@ -746,14 +630,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
       {
@@ -832,6 +716,7 @@ export default class I18nPlugin extends AdminForthPlugin {
             translations: translations.filter(t => stringBanchCopy.includes(t.en_string)),
             updateStrings,
             lang,
+            countryCode: getCountryCodeFromLangCode(lang as SupportedLanguage),
             failedToTranslate,
             needToTranslateByLang,
             promptCost: basePromptTokenLength + banchTokens,
@@ -866,8 +751,8 @@ export default class I18nPlugin extends AdminForthPlugin {
     const translations = await 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) {
@@ -1049,10 +934,7 @@ export default class I18nPlugin extends AdminForthPlugin {
       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}
@@ -1092,151 +974,51 @@ export default class I18nPlugin extends AdminForthPlugin {
     if (!this.externalAppOnly) {
       this.tryProcessAndWatch(adminforth);
 
-      adminforth.tr = async (msg: string | null | undefined, category: string, lang: string, params, pluralizationNumber: number): Promise<string> => {
-        if (!msg) {
-          return msg;
-        }
-
+      this.installBackendTranslator(adminforth, async (msg, category, lang) => {
         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 as SupportedLanguage)) {
-        lang = this.primaryLanguage; // fallback to primary language first
-        if (!this.options.supportedLanguages.includes(lang as SupportedLanguage)) {
-          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 = await this.cache.get(cacheKey);
         if (cached) {
-          result = cached;
+          return cached;
         }
-        if (!result) {
-          const resource = adminforth.resource(resourceConfig.resourceId);
-          const translation = await resource.get([Filters.EQ(this.enFieldName, msg), Filters.EQ(this.options.categoryFieldName, category)]);
-          if (!translation) {
-            await 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?.[this.trFieldNames[lang]];
-            if (!result) {
-              // return english
-              result = msg;
-            }
-          }
-          // cache so even if key does not exist, we will not hit database
-          await 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);
+        const resource = adminforth.resource(resourceConfig.resourceId);
+        const translation = await resource.get([Filters.EQ(this.enFieldName, msg), Filters.EQ(this.options.categoryFieldName, category)]);
+        if (!translation) {
+          await resource.create({
+            [this.enFieldName]: msg,
+            [this.options.categoryFieldName]: category,
+          });
+          this.updateUntranslatedMenuBadge();
         }
 
-        if (params) {
-          for (const [key, value] of Object.entries(params)) {
-            if (result) {
-              result = result.replace(`{${key}}`, value);
-            }
-          }
-        }
+        // do this check here, to faster register missing translations
+        const result = lang === SOURCE_LANGUAGE ? msg : translation?.[this.trFieldNames[lang]] || msg;
+        // cache so even if key does not exist, we will not hit database
+        await this.cache.set(cacheKey, result);
         return result;
-      }
-    }
-  }
-
-  applyPluralization(str: string, number: number, lang: string): string {
-    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: any) : string {
-    // optional method to return unique string representation of plugin instance. 
-    // Needed if plugin can have multiple instances on one resource 
-    return `single`;
   }
 
   async getCategoryTranslations(category: string, lang: string): Promise<Record<string, string>> {
     const resource = this.adminforth.resource(this.resourceConfig.resourceId);
-    const cacheKey = `${this.resourceConfig.resourceId}:${category}:${lang}`;
+    const cacheKey = this.categoryCacheKey(category, lang);
     const cached = await this.cache.get(cacheKey);
     if (cached) {
       return cached;
     }
-    const translations = {};
     const allTranslations = await 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]]]),
+    ));
     await this.cache.set(cacheKey, translations);
     return translations;
   }
 
-  async languagesList(): Promise<{
-    code: SupportedLanguage;
-    nameOnNative: string;
-    nameEnglish: string;
-    emojiFlag: string;
-    svgFlagB64: string;
-  }[]> {
-    return Promise.all(this.options.supportedLanguages.map(async (lang) => {
-      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: await flagEmoji(getCountryCodeFromLangCode(lang)),
-      };
-    }));
-  }
-
   async feedCategoryTranslations(messages: {
     en_string: string;
     source: string;
@@ -1279,19 +1061,7 @@ export default class I18nPlugin extends AdminForthPlugin {
 
 
   setupEndpoints(server: IHttpServer) {
-    server.endpoint({
-      method: 'GET',
-      path: `/plugin/${this.pluginInstanceId}/frontend_messages`,
-      noAuth: true,
-      handler: async ({ query }) => {
-        const lang = query.lang;
-        
-        // form map of translations
-        const translations = await this.getCategoryTranslations('frontend', lang);
-        return translations;
-
-      }
-    });
+    super.setupEndpoints(server);
 
     const lock = new RAMLock();
 
@@ -1452,3 +1222,6 @@ 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';
+export type { I18nBaseOptions, SupportedLanguage } from './types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/i18n",
-  "version": "2.3.2",
+  "version": "2.5.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/types.ts

@@ -8,11 +8,30 @@ 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 {
 
   /* List of language codes which you want to support. Can be either short ISO 639-1 language codes or/and BCP47 tags */
   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')
@@ -26,11 +45,6 @@ export interface PluginOptions extends PluginsCommonOptions {
    */
   categoryFieldName: string;
 
-  /**
-   * Language selector on login page order
-   */
-  loginPageLanguageSelectorOrder?: number;
-
   /**
    * Optional source field to store e.g. file name where it first was captured
    */
@@ -61,14 +75,6 @@ export interface PluginOptions extends PluginsCommonOptions {
    */
   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