@sveltebase/i18n 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -1,6 +1,4 @@
-import * as use_intl_core from 'use-intl/core';
-import { State, PersistentState } from '@svelte-essentials/state';
-import { z } from 'zod';
+import { AppConfig } from 'use-intl/core';
 
 type MessageValue = string | {
     [key: string]: MessageValue;
@@ -17,58 +15,34 @@ type FormatOptions = {
     preset?: "default" | "custom" | "birthday" | "month" | "timestring" | "full";
     withTime?: boolean;
 };
-declare function getLanguage<const TLanguages extends readonly LanguageDefinition[]>(languages: TLanguages, locale: TLanguages[number]["code"], fallbackLocale?: TLanguages[number]["code"]): LanguageDefinition<string, Messages>;
-declare function createLocaleTranslator<const TLanguages extends readonly LanguageDefinition[]>(languages: TLanguages, locale: TLanguages[number]["code"], fallbackLocale?: TLanguages[number]["code"]): use_intl_core._Translator<Messages, never>;
-declare function createLocaleFormatter<TLocale extends string>(locale: TLocale, timeZone?: string): {
-    dateTime: {
-        (value: Date | number, options?: use_intl_core.DateTimeFormatOptions): string;
-        (value: Date | number, format?: string, options?: use_intl_core.DateTimeFormatOptions): string;
-    };
-    number: {
-        (value: number | bigint, options?: use_intl_core.NumberFormatOptions): string;
-        (value: number | bigint, format?: string, options?: use_intl_core.NumberFormatOptions): string;
-    };
-    relativeTime: {
-        (date: number | Date, now?: use_intl_core.RelativeTimeFormatOptions["now"]): string;
-        (date: number | Date, options?: use_intl_core.RelativeTimeFormatOptions): string;
-    };
-    list: {
-        <Value extends string | ReactElement<unknown, any>>(value: Iterable<Value>, options?: Intl.ListFormatOptions): Value extends string ? string : Iterable<ReactElement>;
-        <Value extends string | ReactElement<unknown, any>>(value: Iterable<Value>, format?: string, options?: Intl.ListFormatOptions): Value extends string ? string : Iterable<ReactElement>;
-    };
-    dateTimeRange: {
-        (start: Date | number, end: Date | number, options?: use_intl_core.DateTimeFormatOptions): string;
-        (start: Date | number, end: Date | number, format?: string, options?: use_intl_core.DateTimeFormatOptions): string;
-    };
-};
-declare function createFormatForLocale<const TLanguages extends readonly LanguageDefinition[]>(languages: TLanguages, locale: TLanguages[number]["code"], fallbackLocale?: TLanguages[number]["code"], timeZone?: string): (value?: Date | number | string, options?: FormatOptions) => string | undefined;
 
-type LocaleSchema<TLocale extends string> = z.ZodType<TLocale>;
-type LocaleState<TLocale extends string> = State<TLocale> | PersistentState<LocaleSchema<TLocale>>;
-interface CreateI18nOptions<TLanguages extends readonly LanguageDefinition[], TFormat> {
-    languages: TLanguages;
-    fallbackLocale: TLanguages[number]["code"];
-    signatureLocale?: TLanguages[number]["code"];
-    storageKey?: string;
-    timeZone?: string;
-    createFormat(args: {
-        locale: TLanguages[number]["code"];
-        fallbackLocale: TLanguages[number]["code"];
-        signatureLocale?: TLanguages[number]["code"];
-        languages: TLanguages;
-        timeZone?: string;
-    }): TFormat;
-}
-declare function defineLanguages<const TLanguages extends readonly LanguageDefinition[]>(languages: TLanguages): TLanguages;
-declare function createI18n<const TLanguages extends readonly LanguageDefinition[], TFormat>(options: CreateI18nOptions<TLanguages, TFormat>): {
-    languages: TLanguages;
-    fallbackLocale: TLanguages[number]["code"];
-    signatureLocale: TLanguages[number]["code"] | undefined;
-    localeState: LocaleState<TLanguages[number]["code"]>;
-    setLocale: (locale: TLanguages[number]["code"]) => void;
-    getTranslations: (locale?: TLanguages[number]["code"]) => use_intl_core._Translator<Messages, never>;
-    getFormat: (locale?: TLanguages[number]["code"]) => TFormat;
-    getLanguage: (locale?: TLanguages[number]["code"]) => LanguageDefinition<string, Messages>;
+type Cookie = {
+    name: string;
+    value: string;
 };
+type LocaleCode<TLanguages extends readonly LanguageDefinition[]> = TLanguages[number]["code"];
+type CurrentLanguage<TLanguages extends readonly LanguageDefinition[]> = TLanguages[number];
+type TranslationValues = Record<string, string | number | Date>;
+type Join<TKey extends string, TValue extends string> = `${TKey}.${TValue}`;
+type MessageKeys<TMessages> = TMessages extends string ? never : {
+    [TKey in Extract<keyof TMessages, string>]: TMessages[TKey] extends string ? TKey : TMessages[TKey] extends Record<string, unknown> ? Join<TKey, MessageKeys<TMessages[TKey]>> : never;
+}[Extract<keyof TMessages, string>];
+type AppConfigMessages = AppConfig extends {
+    Messages: infer TMessages;
+} ? TMessages : never;
+type RegisteredMessages = AppConfigMessages;
+type MessageKey = Extract<MessageKeys<RegisteredMessages>, string> extends never ? string : Extract<MessageKeys<RegisteredMessages>, string>;
+type Translate = <TKey extends MessageKey>(key: TKey, values?: TranslationValues) => string;
+type Format = (value?: Date | number | string, options?: FormatOptions) => string | undefined;
+interface I18nInstance<TLanguages extends readonly LanguageDefinition[]> {
+    readonly languages: TLanguages;
+    locale: LocaleCode<TLanguages>;
+    readonly currentLanguage: CurrentLanguage<TLanguages>;
+    init(cookies?: Cookie[]): void;
+}
+declare function getTranslations(): Translate;
+declare function getFormat(): Format;
+declare function createI18n<const TLanguages extends readonly LanguageDefinition[]>(languages: TLanguages, localeStorageKey?: string): I18nInstance<TLanguages>;
+type CreateI18nReturn<TLanguages extends readonly LanguageDefinition[]> = I18nInstance<TLanguages>;
 
-export { type FormatOptions, type LanguageDefinition, type MessageValue, type Messages, createFormatForLocale, createI18n, createLocaleFormatter, createLocaleTranslator, defineLanguages, getLanguage };
+export { type CreateI18nReturn, type CurrentLanguage, type Format, type FormatOptions, type I18nInstance, type LanguageDefinition, type LocaleCode, type MessageKey, type MessageValue, type Messages, type RegisteredMessages, type Translate, type TranslationValues, createI18n, getFormat, getTranslations };

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/create-i18n.ts
-import { PersistentState, State } from "@svelte-essentials/state";
+import { createContext } from "svelte";
+import { PersistentState } from "@sveltebase/state";
 import { z } from "zod";
 
 // src/utils.ts
@@ -36,9 +37,6 @@ var UZ_MONTHS = [
   "Noyabr",
   "Dekabr"
 ];
-function getLocaleCodes(languages) {
-  return languages.map((language) => language.code);
-}
 function getLanguage(languages, locale, fallbackLocale) {
   return languages.find((language) => language.code === locale) ?? (fallbackLocale ? languages.find((language) => language.code === fallbackLocale) : void 0) ?? languages[0];
 }
@@ -157,14 +155,74 @@ function createFormatForLocale(languages, locale, fallbackLocale, timeZone = "As
 }
 
 // src/create-i18n.ts
-function defineLanguages(languages) {
-  return languages;
+var DEFAULT_LOCALE_STORAGE_KEY = "locale";
+var i18nInternals = /* @__PURE__ */ new WeakMap();
+var getI18nContextBase = null;
+var setI18nContextBase = null;
+function ensureContext() {
+  if (!getI18nContextBase || !setI18nContextBase) {
+    [getI18nContextBase, setI18nContextBase] = createContext();
+  }
+  return {
+    get: getI18nContextBase,
+    set: setI18nContextBase
+  };
+}
+function getLocaleCodes(languages) {
+  return languages.map((language) => language.code);
+}
+function getDefaultLocale(languages) {
+  const [defaultLocale] = getLocaleCodes(languages);
+  if (!defaultLocale) {
+    throw new Error("[i18n] createI18n requires at least one language.");
+  }
+  return defaultLocale;
+}
+function getI18nInternal(i18n) {
+  const internal = i18nInternals.get(i18n);
+  if (!internal) {
+    throw new Error("[i18n] Internal i18n state was not found for this instance.");
+  }
+  return {
+    languages: internal.languages,
+    fallbackLocale: internal.fallbackLocale,
+    localeState: internal.localeState
+  };
+}
+function getI18nFromContext() {
+  const { get } = ensureContext();
+  return get();
+}
+function getTranslations() {
+  return ((key, values) => {
+    const i18n = getI18nFromContext();
+    const { languages, fallbackLocale } = getI18nInternal(i18n);
+    const translate = createLocaleTranslator(
+      languages,
+      i18n.locale,
+      fallbackLocale
+    );
+    return translate(key, values);
+  });
+}
+function getFormat() {
+  return (value, options) => {
+    const i18n = getI18nFromContext();
+    const { languages, fallbackLocale } = getI18nInternal(i18n);
+    const format = createFormatForLocale(
+      languages,
+      i18n.locale,
+      fallbackLocale
+    );
+    return format(value, options);
+  };
 }
-function createI18n(options) {
-  const { languages, fallbackLocale, signatureLocale, storageKey, timeZone, createFormat } = options;
+function createI18n(languages, localeStorageKey = DEFAULT_LOCALE_STORAGE_KEY) {
+  ensureContext();
   const localeCodes = getLocaleCodes(languages);
-  const localeSchema = z.string().transform((value, context) => {
-    const nextLocale = value || fallbackLocale;
+  const fallbackLocale = getDefaultLocale(languages);
+  const localeSchema = z.string().optional().transform((value, context) => {
+    const nextLocale = value ?? fallbackLocale;
     if (localeCodes.includes(nextLocale)) {
       return nextLocale;
     }
@@ -174,44 +232,44 @@ function createI18n(options) {
     });
     return z.NEVER;
   });
-  const localeState = storageKey ? new PersistentState(storageKey, localeSchema) : new State(fallbackLocale);
-  function getLocale(locale) {
-    return locale ?? localeState.current;
-  }
-  function setLocale(locale) {
-    localeState.current = localeSchema.parse(locale);
-  }
-  function getTranslations(locale) {
-    return createLocaleTranslator(languages, getLocale(locale), fallbackLocale);
-  }
-  function getFormat(locale) {
-    return createFormat({
-      locale: getLocale(locale),
-      fallbackLocale,
-      signatureLocale,
-      languages,
-      timeZone
-    });
-  }
-  function getCurrentLanguage(locale) {
-    return getLanguage(languages, getLocale(locale), fallbackLocale);
-  }
-  return {
+  const localeState = new PersistentState(
+    localeStorageKey,
+    localeSchema
+  );
+  const i18n = {
+    get languages() {
+      return languages;
+    },
+    get locale() {
+      return localeState.current;
+    },
+    set locale(nextLocale) {
+      localeState.current = localeSchema.parse(nextLocale);
+    },
+    get currentLanguage() {
+      return getLanguage(
+        languages,
+        localeState.current,
+        fallbackLocale
+      );
+    },
+    init(cookies) {
+      if (cookies) {
+        localeState.init(cookies);
+      }
+      const { set } = ensureContext();
+      set(i18n);
+    }
+  };
+  i18nInternals.set(i18n, {
     languages,
     fallbackLocale,
-    signatureLocale,
-    localeState,
-    setLocale,
-    getTranslations,
-    getFormat,
-    getLanguage: getCurrentLanguage
-  };
+    localeState
+  });
+  return i18n;
 }
 export {
-  createFormatForLocale,
   createI18n,
-  createLocaleFormatter,
-  createLocaleTranslator,
-  defineLanguages,
-  getLanguage
+  getFormat,
+  getTranslations
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltebase/i18n",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -18,7 +18,7 @@
     }
   },
   "dependencies": {
-    "@sveltebase/state": "0.1.0",
+    "@sveltebase/state": "0.1.1",
     "date-fns": "^4.1.0",
     "use-intl": "^4.4.0",
     "zod": "^4.1.11"