i18n-typed-store 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -1,56 +1,208 @@
+import { T as TranslationStore } from './context-Dp43aQ0V.js';
+export { I as II18nTypedStoreContext } from './context-Dp43aQ0V.js';
+
+/**
+ * Map of translation module loaders.
+ * Each namespace key maps to an object where each locale key maps to a loader function.
+ *
+ * @template T - Type of translations object (e.g., { common: 'common', errors: 'errors' })
+ * @template L - Type of locales object (e.g., { en: 'en', ru: 'ru' })
+ * @template Module - Type of the raw module loaded from the module loader
+ */
+type TranslationModuleMap<T extends Record<string, string>, L extends Record<string, string>, Module = unknown> = Record<keyof T, Record<keyof L, () => Promise<Module>>>;
+
 /**
  * Creates a map of translation module loaders for all combinations of translations and locales.
+ * This map is used internally by the translation store to lazy-load translation modules.
+ *
+ * @template T - Type of translations object (e.g., { common: 'common', errors: 'errors' })
+ * @template L - Type of locales object (e.g., { en: 'en', ru: 'ru' })
+ * @template Module - Type of the raw module loaded from the module loader
  *
  * @param translations - Object with translation keys
  * @param locales - Object with locale keys
- * @param loadModule - Function to load a translation module for a specific locale and translation
- * @returns Map where each translation key contains an object with loader functions for each locale
+ * @param loadModule - Function to load a translation module for a specific locale and namespace
+ * @returns Immutable map where each namespace key contains an object with loader functions for each locale
+ * @throws {TypeError} If translations or locales are empty objects
+ *
+ * @example
+ * ```ts
+ * const translations = { common: 'common', errors: 'errors' } as const;
+ * const locales = { en: 'en', ru: 'ru' } as const;
+ * const loadModule = async (locale, namespace) => import(`./${namespace}/${locale}.json`);
+ *
+ * const moduleMap = createTranslationModuleMap(translations, locales, loadModule);
+ * moduleMap.common.en() will load './common/en.json'
+ * moduleMap.errors.ru() will load './errors/ru.json'
+ * ```
  */
-declare const createTranslationModuleMap: <T extends Record<string, string>, L extends Record<string, string>, Module = unknown>(translations: T, locales: L, loadModule: (locale: keyof L, translation: keyof T) => Promise<Module>) => Record<keyof T, Record<keyof L, () => Promise<Module>>>;
+declare const createTranslationModuleMap: <T extends Record<string, string>, L extends Record<string, string>, Module = unknown>(translations: T, locales: L, loadModule: (locale: keyof L, namespace: keyof T) => Promise<Module>) => TranslationModuleMap<T, L, Module>;
 
 /**
- * Creates a translation store with typed translations for different locales.
+ * Options for creating a translation store.
  *
- * @param translations - Object with translation keys
- * @param locales - Object with locale keys
- * @param loadModule - Function to load a translation module
- * @param extractTranslation - Function to extract translation data from the loaded module.
- *   Receives three parameters: (module, locale, translation) allowing for locale-specific
- *   or translation-specific extraction logic.
- * @returns Object with a type() method for creating a typed translation store
+ * @template T - Type of translations object (e.g., { common: 'common', errors: 'errors' })
+ * @template L - Type of locales object (e.g., { en: 'en', ru: 'ru' })
+ * @template Module - Type of the raw module loaded from the module loader
+ */
+interface CreateTranslationStoreOptions<T extends Record<string, string>, L extends Record<string, string>, Module = unknown> {
+    /** Object with translation keys */
+    translations: T;
+    /** Object with locale keys */
+    locales: L;
+    /** Function to load a translation module for a specific locale and namespace */
+    loadModule: (locale: keyof L, namespace: keyof T) => Promise<Module>;
+    /**
+     * Function to extract translation data from the loaded module.
+     * Receives three parameters: (module, locale, namespace) allowing for locale-specific
+     * or namespace-specific extraction logic.
+     */
+    extractTranslation: (module: Module, locale: keyof L, namespace: keyof T) => unknown | Promise<unknown>;
+    /**
+     * Whether to delete translations for other locales after loading a new one.
+     * Useful for memory-constrained environments.
+     * @default false
+     */
+    deleteOtherLocalesAfterLoad?: boolean;
+    /**
+     * Whether to load translations from cache by default.
+     * If false, will always reload even if translation is already cached.
+     * @default true
+     */
+    loadFromCache?: boolean;
+    /** Default locale key to use */
+    defaultLocale: keyof L;
+    /**
+     * Whether to use fallback locale for missing translations.
+     * When enabled, translations will be merged with fallback locale translations.
+     * @default false
+     */
+    useFallback?: boolean;
+    /**
+     * Fallback locale key to use when useFallback is true.
+     * If not provided, defaultLocale will be used as fallback.
+     * @default defaultLocale
+     */
+    fallbackLocale?: keyof L;
+    /**
+     * Event name for locale change events.
+     * @default 'change-locale'
+     */
+    changeLocaleEventName?: string;
+}
+
+/**
+ * Creates a translation store factory with typed translations for different locales.
+ * The store supports lazy loading, caching, error handling, and fallback locale merging.
+ *
+ * @template T - Type of translations object (e.g., { common: 'common', errors: 'errors' })
+ * @template L - Type of locales object (e.g., { en: 'en', ru: 'ru' })
+ * @template Module - Type of the raw module loaded from the module loader
+ *
+ * @param options - Configuration options for the translation store
+ * @returns Object with a `type()` method for creating a typed translation store
+ * @throws {TypeError} If required options are invalid
+ *
+ * @example
+ * ```ts
+ * const translations = { common: 'common', errors: 'errors' } as const;
+ * const locales = { en: 'en', ru: 'ru' } as const;
+ *
+ * const storeFactory = createTranslationStore({
+ *   translations,
+ *   locales,
+ *   loadModule: async (locale, namespace) => import(`./${namespace}/${locale}.json`),
+ *   extractTranslation: (module) => module.default || module,
+ *   defaultLocale: 'en',
+ *   useFallback: true,
+ *   fallbackLocale: 'en',
+ * });
+ *
+ * const store = storeFactory.type<{
+ *   common: { greeting: string };
+ *   errors: { notFound: string };
+ * }>();
+ * ```
  */
-declare const createTranslationStore: <T extends Record<string, string>, L extends Record<string, string>, Module = unknown>(translations: T, locales: L, loadModule: (locale: keyof L, translation: keyof T) => Promise<Module>, extractTranslation: (module: Module, locale: keyof L, translation: keyof T) => unknown) => {
+declare const createTranslationStore: <T extends Record<string, string>, L extends Record<string, string>, Module = unknown>({ translations, locales, loadModule, extractTranslation, deleteOtherLocalesAfterLoad, loadFromCache, defaultLocale, useFallback, fallbackLocale, changeLocaleEventName, }: CreateTranslationStoreOptions<T, L, Module>) => {
     /**
      * Creates a typed translation store.
+     * The store provides methods to load and access translations for each locale.
+     * When useFallback is enabled, translations are automatically merged with fallback locale.
      *
-     * @template M - Type of translation object where each key corresponds to a key from translations
+     * @template M - Type of translation modules mapping where each key corresponds to a key from translations
      * @returns Store with methods to load translations for each locale
+     *
+     * @example
+     * ```ts
+     * const store = storeFactory.type<{
+     *   common: { greeting: string; goodbye: string };
+     *   errors: { notFound: string; unauthorized: string };
+     * }>();
+     *
+     * await store.common.load('ru');
+     * // If useFallback is true and 'ru' translation is missing some keys,
+     * // they will be filled from fallback locale (e.g., 'en')
+     * const greeting = store.common.translations.ru.namespace?.greeting;
+     * ```
      */
-    type: <M extends { [K in keyof T]: any; }>() => { [K in keyof T]: {
-        translation?: M[K];
-        load: (locale: keyof L) => Promise<void>;
-    }; };
+    type: <M extends { [K in keyof T]: any; }>() => TranslationStore<T, L, M>;
 };
 
 /**
  * Plural form variants for different plural categories.
  * Based on Unicode CLDR plural rules: zero, one, two, few, many, other.
+ *
+ * @see https://unicode-org.github.io/cldr-staging/charts/latest/supplemental/language_plural_rules.html
+ *
+ * @example
+ * ```ts
+ * const variants: PluralVariants = {
+ *   one: 'item',
+ *   other: 'items'
+ * };
+ * ```
  */
 type PluralVariants = {
+    /** Used for count = 0 (in some languages) */
     zero?: string;
+    /** Used for count = 1 (in most languages) */
     one?: string;
+    /** Used for count = 2 (in some languages like Welsh) */
     two?: string;
+    /** Used for small numbers (e.g., 3-10 in Russian) */
     few?: string;
+    /** Used for large numbers or fractional values */
     many?: string;
-    other?: string;
+    /** Default/fallback variant - MUST be provided for correct pluralization */
+    other: string;
 };
+/**
+ * Valid plural category names according to CLDR.
+ */
+type PluralCategory = keyof PluralVariants;
+
+/**
+ * Options for creating a plural selector.
+ */
+interface CreatePluralSelectorOptions {
+    /**
+     * Whether to throw an error if 'other' variant is missing.
+     * @default false
+     */
+    strict?: boolean;
+}
 
 /**
  * Creates a plural selector function for a specific locale.
- * The returned function selects the appropriate plural form based on the count.
+ * The returned function selects the appropriate plural form based on the count
+ * using Unicode CLDR plural rules.
  *
- * @param locale - Locale string (e.g., 'en', 'ru', 'fr')
+ * @param locale - Locale string (e.g., 'en', 'ru', 'fr', 'uk-UA')
+ * @param options - Configuration options
  * @returns Function that takes a count and plural variants, returns the matching variant
+ * @throws {TypeError} If locale is not a valid string
+ * @throws {Error} If strict mode is enabled and 'other' variant is missing
  *
  * @example
  * ```ts
@@ -58,7 +210,34 @@ type PluralVariants = {
  * selectPlural(1, { one: 'item', other: 'items' }); // => 'item'
  * selectPlural(5, { one: 'item', other: 'items' }); // => 'items'
  * ```
+ *
+ * @example
+ * ```ts
+ * const selectPlural = createPluralSelector('ru');
+ * selectPlural(1, { one: 'элемент', few: 'элемента', many: 'элементов', other: 'элементов' }); // => 'элемент'
+ * selectPlural(2, { one: 'элемент', few: 'элемента', many: 'элементов', other: 'элементов' }); // => 'элемента'
+ * selectPlural(5, { one: 'элемент', few: 'элемента', many: 'элементов', other: 'элементов' }); // => 'элементов'
+ * ```
+ */
+declare const createPluralSelector: (locale: string, options?: CreatePluralSelectorOptions) => ((count: number, variants: PluralVariants) => string);
+
+/**
+ * Event listener function type.
+ *
+ * @template T - Type of event arguments array
+ */
+type Listener<T extends any[] = any[]> = (...args: T) => void;
+/**
+ * Event map type that maps event names to their argument types.
+ *
+ * @example
+ * ```ts
+ * type MyEvents = {
+ *   'user-login': [userId: string, timestamp: number];
+ *   'user-logout': [userId: string];
+ * };
+ * ```
  */
-declare const createPluralSelector: (locale: string) => (count: number, variants: PluralVariants) => string;
+type EventMap = Record<PropertyKey, any[]>;
 
-export { createPluralSelector, createTranslationModuleMap, createTranslationStore };
+export { type CreatePluralSelectorOptions, type CreateTranslationStoreOptions, type EventMap, type Listener, type PluralCategory, type PluralVariants, type TranslationModuleMap, TranslationStore, createPluralSelector, createTranslationModuleMap, createTranslationStore };

package/dist/index.js

@@ -2,39 +2,335 @@
 
 // src/utils/create-translation-module-map.ts
 var createTranslationModuleMap = (translations, locales, loadModule) => {
-  const translationModules = {};
-  for (const translationKey of Object.keys(translations)) {
-    translationModules[translationKey] = {};
+  if (!translations || Object.keys(translations).length === 0) {
+    throw new TypeError("translations must be a non-empty object");
+  }
+  if (!locales || Object.keys(locales).length === 0) {
+    throw new TypeError("locales must be a non-empty object");
+  }
+  if (typeof loadModule !== "function") {
+    throw new TypeError("loadModule must be a function");
+  }
+  const namespaceModules = {};
+  for (const namespaceKey of Object.keys(translations)) {
+    namespaceModules[namespaceKey] = {};
     for (const localeKey of Object.keys(locales)) {
-      translationModules[translationKey][localeKey] = () => loadModule(localeKey, translationKey);
+      namespaceModules[namespaceKey][localeKey] = () => loadModule(localeKey, namespaceKey);
     }
   }
-  return translationModules;
+  return namespaceModules;
 };
 
+// src/utils/event-emitter.ts
+var EventEmitter = class {
+  constructor() {
+    this.listeners = {};
+  }
+  /**
+   * Registers an event listener for the specified event.
+   *
+   * @param event - Event name
+   * @param listener - Listener function
+   * @returns This instance for method chaining
+   */
+  on(event, listener) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = /* @__PURE__ */ new Set();
+    }
+    this.listeners[event].add(listener);
+    return this;
+  }
+  /**
+   * Registers a one-time event listener that will be automatically removed after the first call.
+   *
+   * @param event - Event name
+   * @param listener - Listener function
+   * @returns This instance for method chaining
+   */
+  once(event, listener) {
+    const wrapper = (...args) => {
+      this.off(event, wrapper);
+      listener(...args);
+    };
+    return this.on(event, wrapper);
+  }
+  /**
+   * Removes an event listener. If no listener is provided, removes all listeners for the event.
+   *
+   * @param event - Event name
+   * @param listener - Optional listener function to remove
+   * @returns This instance for method chaining
+   */
+  off(event, listener) {
+    const set = this.listeners[event];
+    if (!set) {
+      return this;
+    }
+    if (!listener) {
+      set.clear();
+    } else {
+      set.delete(listener);
+    }
+    if (set.size === 0) {
+      delete this.listeners[event];
+    }
+    return this;
+  }
+  /**
+   * Emits an event, calling all registered listeners with the provided arguments.
+   *
+   * @param event - Event name
+   * @param args - Event arguments
+   * @returns True if there were listeners, false otherwise
+   */
+  emit(event, ...args) {
+    const set = this.listeners[event];
+    if (!set || set.size === 0) {
+      return false;
+    }
+    [...set].forEach((listener) => listener(...args));
+    return true;
+  }
+  /**
+   * Returns the number of listeners registered for the specified event.
+   *
+   * @param event - Event name
+   * @returns Number of listeners
+   */
+  listenerCount(event) {
+    return this.listeners[event]?.size ?? 0;
+  }
+  /**
+   * Removes all event listeners from all events.
+   *
+   * @returns This instance for method chaining
+   */
+  removeAllListeners() {
+    this.listeners = {};
+    return this;
+  }
+  /**
+   * Returns an array of all event names that have registered listeners.
+   *
+   * @returns Array of event names
+   */
+  eventNames() {
+    return Object.keys(this.listeners);
+  }
+};
+
+// src/utils/smart-merge.ts
+function smartDeepMerge(current, fallback) {
+  if (current == null) return fallback;
+  if (fallback == null) return current;
+  const currentIsObject = typeof current === "object" && !Array.isArray(current);
+  const fallbackIsObject = typeof fallback === "object" && !Array.isArray(fallback);
+  const currentIsArray = Array.isArray(current);
+  const fallbackIsArray = Array.isArray(fallback);
+  if (currentIsObject && !fallbackIsObject && !fallbackIsArray || !currentIsObject && !currentIsArray && fallbackIsObject || currentIsArray && !fallbackIsArray || !currentIsArray && fallbackIsArray) {
+    return fallback;
+  }
+  if (!currentIsObject && !fallbackIsObject) {
+    return current != null ? current : fallback;
+  }
+  const result = { ...current };
+  for (const key in fallback) {
+    if (!(key in result)) {
+      result[key] = fallback[key];
+    } else {
+      const currentValue = result[key];
+      const fallbackValue = fallback[key];
+      const currentValueIsObject = currentValue != null && typeof currentValue === "object" && !Array.isArray(currentValue);
+      const fallbackValueIsObject = fallbackValue != null && typeof fallbackValue === "object" && !Array.isArray(fallbackValue);
+      const currentValueIsArray = Array.isArray(currentValue);
+      const fallbackValueIsArray = Array.isArray(fallbackValue);
+      if (currentValueIsObject && !fallbackValueIsObject && !fallbackValueIsArray || !currentValueIsObject && !currentValueIsArray && fallbackValueIsObject || currentValueIsArray && !fallbackValueIsArray || !currentValueIsArray && fallbackValueIsArray) {
+        result[key] = fallbackValue;
+      } else if (currentValueIsObject && fallbackValueIsObject) {
+        result[key] = smartDeepMerge(currentValue, fallbackValue);
+      } else if (currentValue == null) {
+        result[key] = fallbackValue;
+      }
+    }
+  }
+  return result;
+}
+
 // src/utils/create-translation-store.ts
-var createTranslationStore = (translations, locales, loadModule, extractTranslation) => {
+var createTranslationStore = ({
+  translations,
+  locales,
+  loadModule,
+  extractTranslation,
+  deleteOtherLocalesAfterLoad = false,
+  loadFromCache = true,
+  defaultLocale,
+  useFallback = false,
+  fallbackLocale = defaultLocale,
+  changeLocaleEventName = "change-locale"
+}) => {
+  if (!translations || Object.keys(translations).length === 0) {
+    throw new TypeError("translations must be a non-empty object");
+  }
+  if (!locales || Object.keys(locales).length === 0) {
+    throw new TypeError("locales must be a non-empty object");
+  }
+  if (typeof loadModule !== "function") {
+    throw new TypeError("loadModule must be a function");
+  }
+  if (typeof extractTranslation !== "function") {
+    throw new TypeError("extractTranslation must be a function");
+  }
+  if (!(defaultLocale in locales)) {
+    throw new TypeError(`defaultLocale '${String(defaultLocale)}' must be a key in locales`);
+  }
+  if (useFallback && !(fallbackLocale in locales)) {
+    throw new TypeError(`fallbackLocale '${String(fallbackLocale)}' must be a key in locales`);
+  }
   return {
     /**
      * Creates a typed translation store.
+     * The store provides methods to load and access translations for each locale.
+     * When useFallback is enabled, translations are automatically merged with fallback locale.
      *
-     * @template M - Type of translation object where each key corresponds to a key from translations
+     * @template M - Type of translation modules mapping where each key corresponds to a key from translations
      * @returns Store with methods to load translations for each locale
+     *
+     * @example
+     * ```ts
+     * const store = storeFactory.type<{
+     *   common: { greeting: string; goodbye: string };
+     *   errors: { notFound: string; unauthorized: string };
+     * }>();
+     *
+     * await store.common.load('ru');
+     * // If useFallback is true and 'ru' translation is missing some keys,
+     * // they will be filled from fallback locale (e.g., 'en')
+     * const greeting = store.common.translations.ru.namespace?.greeting;
+     * ```
      */
     type: () => {
-      const translationModuleMap = createTranslationModuleMap(translations, locales, loadModule);
-      const store = {};
-      for (const translationKey of Object.keys(translations)) {
-        store[translationKey] = {
-          translation: void 0,
-          load: async (locale) => {
-            const moduleLoader = translationModuleMap[translationKey][locale];
-            const loadedModule = await moduleLoader();
-            store[translationKey].translation = extractTranslation(
-              loadedModule,
-              locale,
-              translationKey
-            );
+      const namespaceModuleMap = createTranslationModuleMap(translations, locales, loadModule);
+      const emitter = new EventEmitter();
+      const store = {
+        currentLocale: defaultLocale,
+        locales,
+        translationsMap: translations,
+        translations: {},
+        addChangeLocaleListener: (listener) => {
+          emitter.on(changeLocaleEventName, listener);
+        },
+        removeChangeLocaleListener: (listener) => {
+          emitter.off(changeLocaleEventName, listener);
+        },
+        changeLocale: (locale) => {
+          store.currentLocale = locale;
+          emitter.emit(changeLocaleEventName, locale);
+        }
+      };
+      for (const namespaceKey of Object.keys(translations)) {
+        store.translations[namespaceKey] = {
+          currentTranslation: void 0,
+          currentLocale: void 0,
+          translations: Object.fromEntries(
+            Object.keys(locales).map((localeKey) => [
+              localeKey,
+              {
+                namespace: void 0,
+                isLoading: false,
+                isError: false,
+                loadingPromise: void 0
+              }
+            ])
+          ),
+          load: async (locale = store.currentLocale || defaultLocale, fromCache = loadFromCache) => {
+            if (!(locale in locales)) {
+              throw new TypeError(`Invalid locale: '${String(locale)}' is not a valid locale key`);
+            }
+            const namespaceState = store.translations[namespaceKey].translations[locale];
+            if (namespaceState.loadingPromise) {
+              return namespaceState.loadingPromise;
+            }
+            if (namespaceState.isLoading) {
+              return;
+            }
+            const shouldUseCache = namespaceState.namespace && fromCache !== false;
+            if (shouldUseCache) {
+              store.translations[namespaceKey].currentTranslation = namespaceState.namespace;
+              store.translations[namespaceKey].currentLocale = locale;
+              return;
+            }
+            namespaceState.isError = false;
+            namespaceState.isLoading = true;
+            namespaceState.loadingPromise = (async () => {
+              try {
+                const namespaceState2 = store.translations[namespaceKey].translations[locale];
+                const loadedModule = await namespaceModuleMap[namespaceKey][locale]();
+                let currentTranslation = await extractTranslation(
+                  loadedModule,
+                  locale,
+                  namespaceKey
+                );
+                if (useFallback && locale !== fallbackLocale) {
+                  const fallbackState = store.translations[namespaceKey].translations[fallbackLocale];
+                  let fallbackTranslation = fallbackState.namespace;
+                  if (!fallbackTranslation) {
+                    if (fallbackState.loadingPromise) {
+                      await fallbackState.loadingPromise;
+                      fallbackTranslation = fallbackState.namespace;
+                    } else if (!fallbackState.isLoading) {
+                      fallbackState.isError = false;
+                      fallbackState.isLoading = true;
+                      fallbackState.loadingPromise = (async () => {
+                        try {
+                          const fallbackModule = await namespaceModuleMap[namespaceKey][fallbackLocale]();
+                          fallbackTranslation = await extractTranslation(
+                            fallbackModule,
+                            fallbackLocale,
+                            namespaceKey
+                          );
+                          fallbackState.namespace = fallbackTranslation;
+                        } catch (error) {
+                          fallbackState.isError = true;
+                        } finally {
+                          fallbackState.isLoading = false;
+                          fallbackState.loadingPromise = void 0;
+                        }
+                      })();
+                      await fallbackState.loadingPromise;
+                      fallbackTranslation = fallbackState.namespace;
+                    } else {
+                      fallbackTranslation = void 0;
+                    }
+                  }
+                  if (fallbackTranslation) {
+                    currentTranslation = smartDeepMerge(
+                      currentTranslation,
+                      fallbackTranslation
+                    );
+                  }
+                }
+                namespaceState2.namespace = currentTranslation;
+                if (deleteOtherLocalesAfterLoad) {
+                  for (const otherLocaleKey of Object.keys(
+                    store.translations[namespaceKey].translations
+                  )) {
+                    if (otherLocaleKey !== locale && otherLocaleKey !== store.currentLocale) {
+                      store.translations[namespaceKey].translations[otherLocaleKey].namespace = void 0;
+                    }
+                  }
+                }
+                store.translations[namespaceKey].currentTranslation = namespaceState2.namespace;
+                store.translations[namespaceKey].currentLocale = locale;
+              } catch (error) {
+                namespaceState.isError = true;
+                throw error;
+              } finally {
+                namespaceState.isLoading = false;
+                namespaceState.loadingPromise = void 0;
+              }
+            })();
+            return namespaceState.loadingPromise;
           }
         };
       }
@@ -44,15 +340,33 @@ var createTranslationStore = (translations, locales, loadModule, extractTranslat
 };
 
 // src/utils/create-plural-selector.ts
-var createPluralSelector = (locale) => {
-  const pluralRules = new Intl.PluralRules(locale);
+var createPluralSelector = (locale, options = {}) => {
+  if (typeof locale !== "string" || locale.trim().length === 0) {
+    throw new TypeError(`Invalid locale: expected non-empty string, got ${typeof locale}`);
+  }
+  const { strict = false } = options;
+  let pluralRules;
+  try {
+    pluralRules = new Intl.PluralRules(locale);
+  } catch (error) {
+    throw new TypeError(`Invalid locale format: ${locale}. ${error instanceof Error ? error.message : String(error)}`);
+  }
   return (count, variants) => {
+    if (!Number.isFinite(count)) {
+      throw new TypeError(`Invalid count: expected finite number, got ${count}`);
+    }
+    if (strict && !variants.other) {
+      throw new Error("Plural variants must include 'other' variant when strict mode is enabled");
+    }
     const pluralCategory = pluralRules.select(count);
     const selectedVariant = variants[pluralCategory];
-    if (selectedVariant) {
+    if (selectedVariant !== void 0 && selectedVariant !== null) {
       return selectedVariant;
     }
-    return variants.other ?? "";
+    if (variants.other !== void 0) {
+      return variants.other;
+    }
+    return "";
   };
 };