@adminforth/i18n 2.3.2 → 2.4.0

package/base.ts

@@ -0,0 +1,239 @@
+import { AdminForthPlugin } from "adminforth";
+import type { IAdminForth, IHttpServer } from "adminforth";
+import type { I18nBaseOptions, SupportedLanguage } from './types.js';
+import iso6391 from 'iso-639-1';
+import getFlagEmoji from 'country-flag-svg';
+import { parse } from 'bcp-47';
+
+const REGION_CODE_RE = /^[A-Z]{2}$/;
+
+// keys of all translations are original English strings
+export const SOURCE_LANGUAGE = 'en';
+export const PLURAL_SEPARATOR = '|';
+export const SLAVIC_PLURAL_FORMS = 4;
+
+export 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
+};
+
+export function getCountryCodeFromLangCode(lang: SupportedLanguage) {
+  const [langCode, region] = String(lang).split('-');
+  if (region && REGION_CODE_RE.test(region)) {
+    return region.toLowerCase();
+  }
+  return countryISO31661ByLangISO6391[langCode] || langCode;
+}
+
+export function getPrimaryLanguageCode(langCode: SupportedLanguage): string {
+  return String(langCode).split('-')[0];
+}
+
+// languages which need 4 plural forms "zero | singular | 2-4 | 5+" instead of English ones
+export function requiresSlavicPlurals(lang: string): boolean {
+  return getPrimaryLanguageCode(lang as SupportedLanguage) in SLAVIC_PLURAL_EXAMPLES;
+}
+
+export 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;
+  }
+}
+
+/**
+ * Storage-independent part of i18n plugins: language validation, language selector components,
+ * frontend messages endpoint and formatting of translated strings (params and pluralization).
+ * Subclasses provide translations storage by implementing getCategoryTranslations.
+ * Custom components are resolved from this package's custom folder, so subclasses from other packages reuse them.
+ */
+export abstract class I18nBase<O extends I18nBaseOptions = I18nBaseOptions> extends AdminForthPlugin {
+  options: O;
+  primaryLanguage: SupportedLanguage;
+  adminforth: IAdminForth;
+
+  constructor(options: O) {
+    super(options, import.meta.url);
+    this.options = options;
+    this.primaryLanguage = options.primaryLanguage || SOURCE_LANGUAGE;
+    this.validateSupportedLanguages();
+  }
+
+  // app has one translations storage, so plugin instance id does not depend on options
+  instanceUniqueRepresentation(): string {
+    return 'single';
+  }
+
+  abstract getCategoryTranslations(category: string, lang: string): Promise<Record<string, string>>;
+
+  // validate each supported language: ISO 639-1 or BCP-47 with region (e.g., en-GB)
+  validateSupportedLanguages() {
+    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').`);
+      }
+    });
+  }
+
+  injectLanguageSelectors(adminforth: IAdminForth) {
+    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)),
+        }
+      ))
+    };
+
+    (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
+    });
+  }
+
+  // if lang is not supported, fallback to primaryLanguage, then to english
+  resolveLanguage(lang: string): string {
+    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 = SOURCE_LANGUAGE; // final fallback to english
+      }
+    }
+    return lang;
+  }
+
+  formatTranslation(msg: string, translation: string, lang: string, params: Record<string, string> | undefined, pluralizationNumber: number | undefined): string {
+    let result = translation;
+    // if msg has '|' in it, then we need to aplly pluralization
+    if (msg.includes(PLURAL_SEPARATOR) && 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 result;
+  }
+
+  applyPluralization(str: string, number: number, lang: string): string {
+    const choices = str.split(PLURAL_SEPARATOR);
+    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
+  }
+
+  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)),
+      };
+    }));
+  }
+
+  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;
+
+      }
+    });
+  }
+}

package/build.log

@@ -20,5 +20,5 @@ custom/package.json
 custom/pnpm-lock.yaml
 custom/tsconfig.json
 
-sent 48,185 bytes  received 305 bytes  96,980.00 bytes/sec
+sent 48,201 bytes  received 305 bytes  32,337.33 bytes/sec
 total size is 47,033  speedup is 0.97

package/dist/base.d.ts

@@ -0,0 +1,51 @@
+import { AdminForthPlugin } from "adminforth";
+import type { IAdminForth, IHttpServer } from "adminforth";
+import type { I18nBaseOptions, SupportedLanguage } from './types.js';
+export declare const SOURCE_LANGUAGE = "en";
+export declare const PLURAL_SEPARATOR = "|";
+export declare const SLAVIC_PLURAL_FORMS = 4;
+export declare const SLAVIC_PLURAL_EXAMPLES: {
+    uk: string;
+    bg: string;
+    cs: string;
+    hr: string;
+    mk: string;
+    pl: string;
+    sk: string;
+    sl: string;
+    sr: string;
+    be: string;
+    ru: string;
+};
+export declare function getCountryCodeFromLangCode(lang: SupportedLanguage): any;
+export declare function getPrimaryLanguageCode(langCode: SupportedLanguage): string;
+export declare function requiresSlavicPlurals(lang: string): boolean;
+export declare function isValidSupportedLanguageTag(langCode: SupportedLanguage): boolean;
+/**
+ * Storage-independent part of i18n plugins: language validation, language selector components,
+ * frontend messages endpoint and formatting of translated strings (params and pluralization).
+ * Subclasses provide translations storage by implementing getCategoryTranslations.
+ * Custom components are resolved from this package's custom folder, so subclasses from other packages reuse them.
+ */
+export declare abstract class I18nBase<O extends I18nBaseOptions = I18nBaseOptions> extends AdminForthPlugin {
+    options: O;
+    primaryLanguage: SupportedLanguage;
+    adminforth: IAdminForth;
+    constructor(options: O);
+    instanceUniqueRepresentation(): string;
+    abstract getCategoryTranslations(category: string, lang: string): Promise<Record<string, string>>;
+    validateSupportedLanguages(): void;
+    injectLanguageSelectors(adminforth: IAdminForth): void;
+    resolveLanguage(lang: string): string;
+    formatTranslation(msg: string, translation: string, lang: string, params: Record<string, string> | undefined, pluralizationNumber: number | undefined): string;
+    applyPluralization(str: string, number: number, lang: string): string;
+    slavicPluralRule(choice: any, choicesLength: any): 0 | 2 | 1 | 3;
+    languagesList(): Promise<{
+        code: SupportedLanguage;
+        nameOnNative: string;
+        nameEnglish: string;
+        emojiFlag: string;
+        svgFlagB64: string;
+    }[]>;
+    setupEndpoints(server: IHttpServer): void;
+}

package/dist/base.js

@@ -0,0 +1,203 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { AdminForthPlugin } from "adminforth";
+import iso6391 from 'iso-639-1';
+import getFlagEmoji from 'country-flag-svg';
+import { parse } from 'bcp-47';
+const REGION_CODE_RE = /^[A-Z]{2}$/;
+// keys of all translations are original English strings
+export const SOURCE_LANGUAGE = 'en';
+export const PLURAL_SEPARATOR = '|';
+export const SLAVIC_PLURAL_FORMS = 4;
+export 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
+};
+export function getCountryCodeFromLangCode(lang) {
+    const [langCode, region] = String(lang).split('-');
+    if (region && REGION_CODE_RE.test(region)) {
+        return region.toLowerCase();
+    }
+    return countryISO31661ByLangISO6391[langCode] || langCode;
+}
+export function getPrimaryLanguageCode(langCode) {
+    return String(langCode).split('-')[0];
+}
+// languages which need 4 plural forms "zero | singular | 2-4 | 5+" instead of English ones
+export function requiresSlavicPlurals(lang) {
+    return getPrimaryLanguageCode(lang) in SLAVIC_PLURAL_EXAMPLES;
+}
+export 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;
+    }
+}
+/**
+ * Storage-independent part of i18n plugins: language validation, language selector components,
+ * frontend messages endpoint and formatting of translated strings (params and pluralization).
+ * Subclasses provide translations storage by implementing getCategoryTranslations.
+ * Custom components are resolved from this package's custom folder, so subclasses from other packages reuse them.
+ */
+export class I18nBase extends AdminForthPlugin {
+    constructor(options) {
+        super(options, import.meta.url);
+        this.options = options;
+        this.primaryLanguage = options.primaryLanguage || SOURCE_LANGUAGE;
+        this.validateSupportedLanguages();
+    }
+    // app has one translations storage, so plugin instance id does not depend on options
+    instanceUniqueRepresentation() {
+        return 'single';
+    }
+    // validate each supported language: ISO 639-1 or BCP-47 with region (e.g., en-GB)
+    validateSupportedLanguages() {
+        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').`);
+            }
+        });
+    }
+    injectLanguageSelectors(adminforth) {
+        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)),
+            }))
+        };
+        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
+        });
+    }
+    // if lang is not supported, fallback to primaryLanguage, then to english
+    resolveLanguage(lang) {
+        if (!this.options.supportedLanguages.includes(lang)) {
+            lang = this.primaryLanguage; // fallback to primary language first
+            if (!this.options.supportedLanguages.includes(lang)) {
+                lang = SOURCE_LANGUAGE; // final fallback to english
+            }
+        }
+        return lang;
+    }
+    formatTranslation(msg, translation, lang, params, pluralizationNumber) {
+        let result = translation;
+        // if msg has '|' in it, then we need to aplly pluralization
+        if (msg.includes(PLURAL_SEPARATOR) && 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 result;
+    }
+    applyPluralization(str, number, lang) {
+        const choices = str.split(PLURAL_SEPARATOR);
+        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;
+    }
+    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)),
+                };
+            })));
+        });
+    }
+    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;
+            })
+        });
+    }
+}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { AdminForthPlugin } from "adminforth";
 import type { IAdminForth, IHttpServer, AdminForthResourceColumn, AdminForthResource, AdminUser } from "adminforth";
 import type { PluginOptions, SupportedLanguage } from './types.js';
+import { I18nBase } from './base.js';
 interface IFailedTranslation {
     lang: SupportedLanguage;
     en_string: string;
@@ -11,8 +11,7 @@ interface ICachingAdapter {
     set(key: string, value: any): Promise<void>;
     clear(key: string): Promise<void>;
 }
-export default class I18nPlugin extends AdminForthPlugin {
-    options: PluginOptions;
+export default class I18nPlugin extends I18nBase<PluginOptions> {
     emailField: AdminForthResourceColumn;
     passwordField: AdminForthResourceColumn;
     authResource: AdminForthResource;
@@ -22,10 +21,8 @@ export default class I18nPlugin extends AdminForthPlugin {
     cache: ICachingAdapter;
     primaryKeyFieldName: string;
     menuItemWithBadgeId: string;
-    adminforth: IAdminForth;
     externalAppOnly: boolean;
     fullCompleatedFieldValue: string;
-    primaryLanguage: SupportedLanguage;
     constructor(options: PluginOptions);
     computeCompletedFieldValue(record: any): Promise<string>;
     updateUntranslatedMenuBadge(): Promise<void>;
@@ -63,21 +60,12 @@ export default class I18nPlugin extends AdminForthPlugin {
     processExtractedMessages(adminforth: IAdminForth, filePath: string): Promise<void>;
     tryProcessAndWatch(adminforth: IAdminForth): Promise<void>;
     validateConfigAfterDiscover(adminforth: IAdminForth, resourceConfig: AdminForthResource): void;
-    applyPluralization(str: string, number: number, lang: string): string;
-    slavicPluralRule(choice: any, choicesLength: any): 3 | 0 | 2 | 1;
-    instanceUniqueRepresentation(pluginOptions: any): string;
     getCategoryTranslations(category: string, lang: string): Promise<Record<string, string>>;
-    languagesList(): Promise<{
-        code: SupportedLanguage;
-        nameOnNative: string;
-        nameEnglish: string;
-        emojiFlag: string;
-        svgFlagB64: string;
-    }[]>;
     feedCategoryTranslations(messages: {
         en_string: string;
         source: string;
     }[], category: string): Promise<void>;
     setupEndpoints(server: IHttpServer): void;
 }
-export {};
+export { I18nBase, getCountryCodeFromLangCode, getPrimaryLanguageCode, isValidSupportedLanguageTag, requiresSlavicPlurals, SOURCE_LANGUAGE, PLURAL_SEPARATOR, SLAVIC_PLURAL_FORMS } from './base.js';
+export type { I18nBaseOptions, SupportedLanguage } from './types.js';

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, getPrimaryLanguageCode, requiresSlavicPlurals, SLAVIC_PLURAL_EXAMPLES } 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,13 +71,11 @@ 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';
     }
     computeCompletedFieldValue(record) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -169,12 +117,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)) {
@@ -293,31 +235,9 @@ 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;
@@ -628,14 +548,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 4 slavic forms (in format "zero count | singular count | 2-4 | 5+") 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
       {
@@ -895,13 +815,7 @@ export default class I18nPlugin extends AdminForthPlugin {
                     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
-                    }
-                }
+                lang = this.resolveLanguage(lang);
                 let result;
                 // try to get translation from cache
                 const cacheKey = `${resourceConfig.resourceId}:${category}:${lang}:${msg}`;
@@ -935,52 +849,10 @@ export default class I18nPlugin extends AdminForthPlugin {
                     // 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 result;
+                return this.formatTranslation(msg, result, lang, params, pluralizationNumber);
             });
         }
     }
-    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);
@@ -999,22 +871,6 @@ export default class I18nPlugin extends AdminForthPlugin {
             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 +905,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 +1049,4 @@ export default class I18nPlugin extends AdminForthPlugin {
         });
     }
 }
+export { I18nBase, getCountryCodeFromLangCode, getPrimaryLanguageCode, isValidSupportedLanguageTag, requiresSlavicPlurals, SOURCE_LANGUAGE, PLURAL_SEPARATOR, SLAVIC_PLURAL_FORMS } 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

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, getPrimaryLanguageCode, requiresSlavicPlurals, SLAVIC_PLURAL_EXAMPLES } 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,20 +89,15 @@ 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) {
@@ -201,13 +139,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)) {
@@ -341,35 +272,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
@@ -746,14 +651,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 4 slavic forms (in format "zero count | singular count | 2-4 | 5+") 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
       {
@@ -1102,13 +1007,7 @@ export default class I18nPlugin extends AdminForthPlugin {
         }
         // 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
-        }
-      }
+        lang = this.resolveLanguage(lang);
 
         let result;
         // try to get translation from cache
@@ -1143,59 +1042,11 @@ export default class I18nPlugin extends AdminForthPlugin {
           // 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);
-        }
-
-        if (params) {
-          for (const [key, value] of Object.entries(params)) {
-            if (result) {
-              result = result.replace(`{${key}}`, value);
-            }
-          }
-        }
-        return result;
+        return this.formatTranslation(msg, result, lang, params, pluralizationNumber);
       }
     }
   }
 
-  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}`;
@@ -1213,30 +1064,6 @@ export default class I18nPlugin extends AdminForthPlugin {
     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 +1106,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 +1267,6 @@ export default class I18nPlugin extends AdminForthPlugin {
   }
 
 }
+
+export { I18nBase, getCountryCodeFromLangCode, getPrimaryLanguageCode, isValidSupportedLanguageTag, requiresSlavicPlurals, SOURCE_LANGUAGE, PLURAL_SEPARATOR, SLAVIC_PLURAL_FORMS } 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.4.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