@vaadin/hilla-react-i18n 24.7.0-alpha9 → 24.7.0-beta3

package/FormatCache.d.ts

@@ -1,7 +1,6 @@
-import { IntlMessageFormat } from 'intl-messageformat';
+import { IntlMessageFormat } from "intl-messageformat";
 export declare class FormatCache {
-    #private;
-    constructor(language: string);
-    getFormat(translation: string): IntlMessageFormat;
+	#private;
+	constructor(language: string);
+	getFormat(translation: string): IntlMessageFormat;
 }
-//# sourceMappingURL=FormatCache.d.ts.map

package/FormatCache.js

@@ -1,25 +1,21 @@
 import { IntlMessageFormat } from "intl-messageformat";
-class FormatCache {
-  #language;
-  #formats = /* @__PURE__ */ new Map();
-  constructor(language) {
-    let supportedLocales = [];
-    try {
-      supportedLocales = Intl.NumberFormat.supportedLocalesOf(language);
-    } catch (e) {
-    }
-    this.#language = supportedLocales.length > 0 ? supportedLocales[0] : navigator.language;
-  }
-  getFormat(translation) {
-    let format = this.#formats.get(translation);
-    if (!format) {
-      format = new IntlMessageFormat(translation, this.#language);
-      this.#formats.set(translation, format);
-    }
-    return format;
-  }
+export class FormatCache {
+	#language;
+	#formats = new Map();
+	constructor(language) {
+		let supportedLocales = [];
+		try {
+			supportedLocales = Intl.NumberFormat.supportedLocalesOf(language);
+		} catch {}
+		this.#language = supportedLocales.length > 0 ? supportedLocales[0] : navigator.language;
+	}
+	getFormat(translation) {
+		let format = this.#formats.get(translation);
+		if (!format) {
+			format = new IntlMessageFormat(translation, this.#language);
+			this.#formats.set(translation, format);
+		}
+		return format;
+	}
 }
-export {
-  FormatCache
-};
-//# sourceMappingURL=FormatCache.js.map
+//# sourceMappingURL=./FormatCache.js.map

package/FormatCache.js.map

@@ -1,7 +1 @@
-{
-  "version": 3,
-  "sources": ["src/FormatCache.ts"],
-  "sourcesContent": ["import { IntlMessageFormat } from 'intl-messageformat';\n\nexport class FormatCache {\n  readonly #language: string;\n  readonly #formats = new Map<string, IntlMessageFormat>();\n\n  constructor(language: string) {\n    // Ensure that the language is supported by Intl.NumberFormat, which IntlMessageFormat uses internally\n    // Fall back to navigator.language if the given language is not supported\n    let supportedLocales: string[] = [];\n    try {\n      supportedLocales = Intl.NumberFormat.supportedLocalesOf(language);\n    } catch (e) {}\n    this.#language = supportedLocales.length > 0 ? supportedLocales[0] : navigator.language;\n  }\n\n  getFormat(translation: string): IntlMessageFormat {\n    let format = this.#formats.get(translation);\n    if (!format) {\n      format = new IntlMessageFormat(translation, this.#language);\n      this.#formats.set(translation, format);\n    }\n    return format;\n  }\n}\n"],
-  "mappings": "AAAA,SAAS,yBAAyB;AAE3B,MAAM,YAAY;AAAA,EACd;AAAA,EACA,WAAW,oBAAI,IAA+B;AAAA,EAEvD,YAAY,UAAkB;AAG5B,QAAI,mBAA6B,CAAC;AAClC,QAAI;AACF,yBAAmB,KAAK,aAAa,mBAAmB,QAAQ;AAAA,IAClE,SAAS,GAAG;AAAA,IAAC;AACb,SAAK,YAAY,iBAAiB,SAAS,IAAI,iBAAiB,CAAC,IAAI,UAAU;AAAA,EACjF;AAAA,EAEA,UAAU,aAAwC;AAChD,QAAI,SAAS,KAAK,SAAS,IAAI,WAAW;AAC1C,QAAI,CAAC,QAAQ;AACX,eAAS,IAAI,kBAAkB,aAAa,KAAK,SAAS;AAC1D,WAAK,SAAS,IAAI,aAAa,MAAM;AAAA,IACvC;AACA,WAAO;AAAA,EACT;AACF;",
-  "names": []
-}
+{"mappings":"AAAA,SAAS,6CAA8C;AAEvD,OAAO,MAAM,YAAY;CACvB,AAASA;CACT,AAASC,WAAW,IAAI;CAExB,YAAYC,UAAkB;EAG5B,IAAIC,mBAA6B,CAAE;AACnC,MAAI;AACF,sBAAmB,KAAK,aAAa,mBAAmB,SAAS;EAClE,QAAO,CAAE;AACV,OAAKH,YAAY,iBAAiB,SAAS,IAAI,iBAAiB,KAAK,UAAU;CAChF;CAED,UAAUI,aAAwC;EAChD,IAAI,SAAS,KAAKH,SAAS,IAAI,YAAY;AAC3C,OAAK,QAAQ;AACX,YAAS,IAAI,kBAAkB,aAAa,KAAKD;AACjD,QAAKC,SAAS,IAAI,aAAa,OAAO;EACvC;AACD,SAAO;CACR;AACF","names":["#language","#formats","language: string","supportedLocales: string[]","translation: string"],"sources":["/opt/agent/work/1af72d8adc613024/hilla/packages/ts/react-i18n/src/FormatCache.ts"],"sourcesContent":["import { IntlMessageFormat } from 'intl-messageformat';\n\nexport class FormatCache {\n  readonly #language: string;\n  readonly #formats = new Map<string, IntlMessageFormat>();\n\n  constructor(language: string) {\n    // Ensure that the language is supported by Intl.NumberFormat, which IntlMessageFormat uses internally\n    // Fall back to navigator.language if the given language is not supported\n    let supportedLocales: string[] = [];\n    try {\n      supportedLocales = Intl.NumberFormat.supportedLocalesOf(language);\n    } catch {}\n    this.#language = supportedLocales.length > 0 ? supportedLocales[0] : navigator.language;\n  }\n\n  getFormat(translation: string): IntlMessageFormat {\n    let format = this.#formats.get(translation);\n    if (!format) {\n      format = new IntlMessageFormat(translation, this.#language);\n      this.#formats.set(translation, format);\n    }\n    return format;\n  }\n}\n"],"version":3}

package/backend.d.ts

@@ -1,8 +1,7 @@
-import type { TranslationsResult } from './types.js';
+import type { TranslationsResult } from "./types.js";
 export interface I18nBackend {
-    loadTranslations(language: string, chunks?: readonly string[]): Promise<TranslationsResult>;
+	loadTranslations(language: string, chunks?: readonly string[]): Promise<TranslationsResult>;
 }
 export declare class DefaultBackend implements I18nBackend {
-    loadTranslations(language: string, chunks?: readonly string[]): Promise<TranslationsResult>;
+	loadTranslations(language: string, chunks?: readonly string[]): Promise<TranslationsResult>;
 }
-//# sourceMappingURL=backend.d.ts.map

package/backend.js

@@ -1,23 +1,20 @@
-class DefaultBackend {
-  async loadTranslations(language, chunks) {
-    const params = new URLSearchParams([
-      ["v-r", "i18n"],
-      ["langtag", language],
-      ...(chunks ?? []).map((chunk) => ["chunks", chunk])
-    ]);
-    const response = await fetch(`./?${params.toString()}`);
-    if (!response.ok) {
-      throw new Error("Failed fetching translations.");
-    }
-    const retrievedLocale = response.headers.get("X-Vaadin-Retrieved-Locale");
-    const translations = await response.json();
-    return {
-      translations,
-      resolvedLanguage: retrievedLocale ?? void 0
-    };
-  }
+export class DefaultBackend {
+	async loadTranslations(language, chunks) {
+		const params = new URLSearchParams([
+			["v-r", "i18n"],
+			["langtag", language],
+			...(chunks ?? []).map((chunk) => ["chunks", chunk])
+		]);
+		const response = await fetch(`./?${params.toString()}`);
+		if (!response.ok) {
+			throw new Error("Failed fetching translations.");
+		}
+		const retrievedLocale = response.headers.get("X-Vaadin-Retrieved-Locale");
+		const translations = await response.json();
+		return {
+			translations,
+			resolvedLanguage: retrievedLocale ?? undefined
+		};
+	}
 }
-export {
-  DefaultBackend
-};
-//# sourceMappingURL=backend.js.map
+//# sourceMappingURL=./backend.js.map

package/backend.js.map

@@ -1,7 +1 @@
-{
-  "version": 3,
-  "sources": ["src/backend.ts"],
-  "sourcesContent": ["import type { Translations, TranslationsResult } from './types.js';\n\nexport interface I18nBackend {\n  loadTranslations(language: string, chunks?: readonly string[]): Promise<TranslationsResult>;\n}\n\nexport class DefaultBackend implements I18nBackend {\n  async loadTranslations(language: string, chunks?: readonly string[]): Promise<TranslationsResult> {\n    const params = new URLSearchParams([\n      ['v-r', 'i18n'],\n      ['langtag', language],\n      ...(chunks ?? []).map((chunk) => ['chunks', chunk]),\n    ]);\n    const response = await fetch(`./?${params.toString()}`);\n    if (!response.ok) {\n      throw new Error('Failed fetching translations.');\n    }\n    const retrievedLocale = response.headers.get('X-Vaadin-Retrieved-Locale');\n    const translations: Translations = await response.json();\n    return {\n      translations,\n      resolvedLanguage: retrievedLocale ?? undefined,\n    };\n  }\n}\n"],
-  "mappings": "AAMO,MAAM,eAAsC;AAAA,EACjD,MAAM,iBAAiB,UAAkB,QAAyD;AAChG,UAAM,SAAS,IAAI,gBAAgB;AAAA,MACjC,CAAC,OAAO,MAAM;AAAA,MACd,CAAC,WAAW,QAAQ;AAAA,MACpB,IAAI,UAAU,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,KAAK,CAAC;AAAA,IACpD,CAAC;AACD,UAAM,WAAW,MAAM,MAAM,MAAM,OAAO,SAAS,CAAC,EAAE;AACtD,QAAI,CAAC,SAAS,IAAI;AAChB,YAAM,IAAI,MAAM,+BAA+B;AAAA,IACjD;AACA,UAAM,kBAAkB,SAAS,QAAQ,IAAI,2BAA2B;AACxE,UAAM,eAA6B,MAAM,SAAS,KAAK;AACvD,WAAO;AAAA,MACL;AAAA,MACA,kBAAkB,mBAAmB;AAAA,IACvC;AAAA,EACF;AACF;",
-  "names": []
-}
+{"mappings":"AAMA,OAAO,MAAM,eAAsC;CACjD,MAAM,iBAAiBA,UAAkBC,QAAyD;EAChG,MAAM,SAAS,IAAI,gBAAgB;GACjC,CAAC,OAAO,MAAO;GACf,CAAC,WAAW,QAAS;GACrB,GAAG,CAAC,UAAU,CAAE,GAAE,IAAI,CAAC,UAAU,CAAC,UAAU,KAAM,EAAC;EACpD;EACD,MAAM,WAAW,MAAM,OAAO,KAAK,OAAO,UAAU,CAAC,EAAE;AACvD,OAAK,SAAS,IAAI;AAChB,SAAM,IAAI,MAAM;EACjB;EACD,MAAM,kBAAkB,SAAS,QAAQ,IAAI,4BAA4B;EACzE,MAAMC,eAA6B,MAAM,SAAS,MAAM;AACxD,SAAO;GACL;GACA,kBAAkB,mBAAmB;EACtC;CACF;AACF","names":["language: string","chunks?: readonly string[]","translations: Translations"],"sources":["/opt/agent/work/1af72d8adc613024/hilla/packages/ts/react-i18n/src/backend.ts"],"sourcesContent":["import type { Translations, TranslationsResult } from './types.js';\n\nexport interface I18nBackend {\n  loadTranslations(language: string, chunks?: readonly string[]): Promise<TranslationsResult>;\n}\n\nexport class DefaultBackend implements I18nBackend {\n  async loadTranslations(language: string, chunks?: readonly string[]): Promise<TranslationsResult> {\n    const params = new URLSearchParams([\n      ['v-r', 'i18n'],\n      ['langtag', language],\n      ...(chunks ?? []).map((chunk) => ['chunks', chunk]),\n    ]);\n    const response = await fetch(`./?${params.toString()}`);\n    if (!response.ok) {\n      throw new Error('Failed fetching translations.');\n    }\n    const retrievedLocale = response.headers.get('X-Vaadin-Retrieved-Locale');\n    const translations: Translations = await response.json();\n    return {\n      translations,\n      resolvedLanguage: retrievedLocale ?? undefined,\n    };\n  }\n}\n"],"version":3}

package/index.d.ts

@@ -1,144 +1,134 @@
-import { type ReadonlySignal } from '@vaadin/hilla-react-signals';
-import type { I18nOptions } from './types.js';
+import { type ReadonlySignal } from "@vaadin/hilla-react-signals";
+import type { I18nOptions } from "./types.js";
 export declare class I18n {
-    #private;
-    constructor();
-    /**
-     * Returns a signal indicating whether the I18n instance has been initialized.
-     * The instance is considered initialized after `configure` has been called
-     * and translations for the initial language have been loaded. Can be used to
-     * show a placeholder or loading indicator until the translations are ready.
-     *
-     * Subscribers to this signal will be notified when initialization is complete
-     * and translations are ready to be used.
-     */
-    get initialized(): ReadonlySignal<boolean>;
-    /**
-     * Returns a signal with the currently configured language.
-     *
-     * Subscribers to this signal will be notified when the language has changed
-     * and new translations have been loaded.
-     */
-    get language(): ReadonlySignal<string | undefined>;
-    /**
-     * Returns a signal with the resolved language. The resolved language is the
-     * language that was actually used to load translations. It may differ from
-     * the configured language if there are no translations available for the
-     * configured language. For example, when setting the language to "de-DE" but
-     * translations are only available for "de", the resolved language will be
-     * "de".
-     */
-    get resolvedLanguage(): ReadonlySignal<string | undefined>;
-    /**
-     * Initializes the I18n instance. This method should be called once to load
-     * translations for the initial language. The `translate` API will not return
-     * properly translated strings until the initializations has completed.
-     *
-     * The initialization runs asynchronously as translations are loaded from the
-     * backend. The method returns a promise that resolves when the translations
-     * have been loaded, after which the `translate` API can safely be used.
-     *
-     * The initial language is determined as follows:
-     * 1. If a user opens the app for the first time, the browser language is used.
-     * 2. If the language has been changed in a previous usage of the app using
-     * `setLanguage`, the last used language is used. The last used language is
-     * automatically stored in local storage.
-     *
-     * Alternatively, the initial language can be explicitly configured using the
-     * `language` option. The language should be a valid IETF BCP 47 language tag,
-     * such as `en` or `en-US`.
-     *
-     * @param options - Optional options object to specify the initial language.
-     */
-    configure(options?: I18nOptions): Promise<void>;
-    /**
-     * Changes the current language and loads translations for the new language.
-     * Components using the `translate` API will automatically re-render, and
-     * subscribers to the `language` signal will be notified, when the new
-     * translations have been loaded.
-     *
-     * The language should be a valid IETF BCP 47 language tag, such as `en` or
-     * `en-US`.
-     *
-     * If there is no translation file for that specific language tag, the backend
-     * will try to load the translation file for the parent language tag. For
-     * example, if there is no translation file for `en-US`, the backend will try
-     * to load the translation file for `en`. Otherwise, it will fall back to the
-     * default translation file `translations.properties`.
-     *
-     * Changing the language is an asynchronous operation. The method returns a
-     * promise that resolves when the translations for the new language have been
-     * loaded.
-     *
-     * @param newLanguage - a valid IETF BCP 47 language tag, such as `en` or `en-US`
-     */
-    setLanguage(newLanguage: string): Promise<void>;
-    /**
-     * Registers the chunk name for loading translations, and loads the
-     * translations for the specified chunk.
-     *
-     * @internal only for automatic internal calls from production JS bundles
-     *
-     * @param chunkName - the production JS bundle chunk name
-     */
-    registerChunk(chunkName: string): Promise<void>;
-    private updateLanguage;
-    /**
-     * Reloads all translations for the current language. This method should only
-     * be used for HMR in development mode.
-     */
-    private reloadTranslations;
-    /**
-     * Returns a translated string for the given translation key. The key should
-     * match a key in the loaded translations. If no translation is found for the
-     * key, the key itself is returned.
-     *
-     * Translations may contain placeholders, following the ICU MessageFormat
-     * syntax. They can be replaced by passing a `params` object with placeholder
-     * values, where keys correspond to the placeholder names and values are the
-     * replacement value. Values should be basic types such as strings, numbers,
-     * or dates that match the placeholder format configured in the translation
-     * string. For example, when using a placeholder `{count, number}`, the value
-     * should be a number, when using `{date, date}`, the value should be a Date
-     * object, and so on.
-     *
-     * This method internally accesses a signal, meaning that React components
-     * that use it will automatically re-render when translations change.
-     * Likewise, signal effects automatically subscribe to translation changes
-     * when calling this method.
-     *
-     * @param key - The translation key to translate
-     * @param params - Optional object with placeholder values
-     */
-    translate(key: string, params?: Record<string, unknown>): string;
+	#private;
+	constructor();
+	/**
+	* Returns a signal indicating whether the I18n instance has been initialized.
+	* The instance is considered initialized after `configure` has been called
+	* and translations for the initial language have been loaded. Can be used to
+	* show a placeholder or loading indicator until the translations are ready.
+	*
+	* Subscribers to this signal will be notified when initialization is complete
+	* and translations are ready to be used.
+	*/
+	get initialized(): ReadonlySignal<boolean>;
+	/**
+	* Returns a signal with the currently configured language.
+	*
+	* Subscribers to this signal will be notified when the language has changed
+	* and new translations have been loaded.
+	*/
+	get language(): ReadonlySignal<string | undefined>;
+	/**
+	* Returns a signal with the resolved language. The resolved language is the
+	* language that was actually used to load translations. It may differ from
+	* the configured language if there are no translations available for the
+	* configured language. For example, when setting the language to "de-DE" but
+	* translations are only available for "de", the resolved language will be
+	* "de".
+	*/
+	get resolvedLanguage(): ReadonlySignal<string | undefined>;
+	/**
+	* Initializes the I18n instance. This method should be called once to load
+	* translations for the initial language. The `translate` API will not return
+	* properly translated strings until the initializations has completed.
+	*
+	* The initialization runs asynchronously as translations are loaded from the
+	* backend. The method returns a promise that resolves when the translations
+	* have been loaded, after which the `translate` API can safely be used.
+	*
+	* The initial language is determined as follows:
+	* 1. If a user opens the app for the first time, the browser language is used.
+	* 2. If the language has been changed in a previous usage of the app using
+	* `setLanguage`, the last used language is used. The last used language is
+	* automatically stored in local storage.
+	*
+	* Alternatively, the initial language can be explicitly configured using the
+	* `language` option. The language should be a valid IETF BCP 47 language tag,
+	* such as `en` or `en-US`.
+	*
+	* @param options - Optional options object to specify the initial language.
+	*/
+	configure(options?: I18nOptions): Promise<void>;
+	/**
+	* Changes the current language and loads translations for the new language.
+	* Components using the `translate` API will automatically re-render, and
+	* subscribers to the `language` signal will be notified, when the new
+	* translations have been loaded.
+	*
+	* The language should be a valid IETF BCP 47 language tag, such as `en` or
+	* `en-US`.
+	*
+	* If there is no translation file for that specific language tag, the backend
+	* will try to load the translation file for the parent language tag. For
+	* example, if there is no translation file for `en-US`, the backend will try
+	* to load the translation file for `en`. Otherwise, it will fall back to the
+	* default translation file `translations.properties`.
+	*
+	* Changing the language is an asynchronous operation. The method returns a
+	* promise that resolves when the translations for the new language have been
+	* loaded.
+	*
+	* @param newLanguage - a valid IETF BCP 47 language tag, such as `en` or `en-US`
+	*/
+	setLanguage(newLanguage: string): Promise<void>;
+	private updateLanguage;
+	/**
+	* Reloads all translations for the current language. This method should only
+	* be used for HMR in development mode.
+	*/
+	private reloadTranslations;
+	/**
+	* Returns a translated string for the given translation key. The key should
+	* match a key in the loaded translations. If no translation is found for the
+	* key, the key itself is returned.
+	*
+	* Translations may contain placeholders, following the ICU MessageFormat
+	* syntax. They can be replaced by passing a `params` object with placeholder
+	* values, where keys correspond to the placeholder names and values are the
+	* replacement value. Values should be basic types such as strings, numbers,
+	* or dates that match the placeholder format configured in the translation
+	* string. For example, when using a placeholder `{count, number}`, the value
+	* should be a number, when using `{date, date}`, the value should be a Date
+	* object, and so on.
+	*
+	* This method internally accesses a signal, meaning that React components
+	* that use it will automatically re-render when translations change.
+	* Likewise, signal effects automatically subscribe to translation changes
+	* when calling this method.
+	*
+	* @param key - The translation key to translate
+	* @param params - Optional object with placeholder values
+	*/
+	translate(key: string, params?: Record<string, unknown>): string;
 }
 /**
- * The global I18n instance that is used to initialize translations, change the
- * current language, and translate strings.
- */
+* The global I18n instance that is used to initialize translations, change the
+* current language, and translate strings.
+*/
 export declare const i18n: I18n;
 /**
- * Returns a translated string for the given translation key. The key should
- * match a key in the loaded translations. If no translation is found for the
- * key, the key itself is returned.
- *
- * Translations may contain placeholders, following the ICU MessageFormat
- * syntax. They can be replaced by passing a `params` object with placeholder
- * values, where keys correspond to the placeholder names and values are the
- * replacement value. Values should be basic types such as strings, numbers,
- * or dates that match the placeholder format configured in the translation
- * string. For example, when using a placeholder `{count, number}`, the value
- * should be a number, when using `{date, date}`, the value should be a Date
- * object, and so on.
- *
- * This method internally accesses a signal, meaning that React components
- * that use it will automatically re-render when translations change.
- * Likewise, signal effects automatically subscribe to translation changes
- * when calling this method.
- *
- * This function is a shorthand for `i18n.translate` of the global I18n instance.
- *
- * @param key - The translation key to translate
- * @param params - Optional object with placeholder values
- */ export declare function translate(key: string, params?: Record<string, unknown>): string;
-//# sourceMappingURL=index.d.ts.map
+* Returns a translated string for the given translation key. The key should
+* match a key in the loaded translations. If no translation is found for the
+* key, the key itself is returned.
+*
+* Translations may contain placeholders, following the ICU MessageFormat
+* syntax. They can be replaced by passing a `params` object with placeholder
+* values, where keys correspond to the placeholder names and values are the
+* replacement value. Values should be basic types such as strings, numbers,
+* or dates that match the placeholder format configured in the translation
+* string. For example, when using a placeholder `{count, number}`, the value
+* should be a number, when using `{date, date}`, the value should be a Date
+* object, and so on.
+*
+* This method internally accesses a signal, meaning that React components
+* that use it will automatically re-render when translations change.
+* Likewise, signal effects automatically subscribe to translation changes
+* when calling this method.
+*
+* This function is a shorthand for `i18n.translate` of the global I18n instance.
+*
+* @param key - The translation key to translate
+* @param params - Optional object with placeholder values
+*/ export declare function translate(key: string, params?: Record<string, unknown>): string;

package/index.js

@@ -3,218 +3,239 @@ import { DefaultBackend } from "./backend.js";
 import { FormatCache } from "./FormatCache.js";
 import { getLanguageSettings, updateLanguageSettings } from "./settings.js";
 function determineInitialLanguage(options) {
-  if (options?.language) {
-    return options.language;
-  }
-  const settings = getLanguageSettings();
-  if (settings?.language) {
-    return settings.language;
-  }
-  return navigator.language;
+	if (options?.language) {
+		return options.language;
+	}
+	const settings = getLanguageSettings();
+	if (settings?.language) {
+		return settings.language;
+	}
+	return navigator.language;
 }
-class I18n {
-  #backend = new DefaultBackend();
-  #initialized = signal(false);
-  #language = signal(void 0);
-  #translations = signal({});
-  #resolvedLanguage = signal(void 0);
-  #chunks = /* @__PURE__ */ new Set();
-  #formatCache = new FormatCache(navigator.language);
-  constructor() {
-    if (!globalThis.Vaadin?.featureFlags?.hillaI18n) {
-      throw new Error(
-        `The Hilla I18n API is currently considered experimental and may change in the future. To use it you need to explicitly enable it in Copilot or by adding com.vaadin.experimental.hillaI18n=true to vaadin-featureflags.properties`
-      );
-    }
-    if (import.meta.hot) {
-      import.meta.hot.on("translations-update", () => {
-        this.reloadTranslations();
-      });
-    }
-  }
-  /**
-   * Returns a signal indicating whether the I18n instance has been initialized.
-   * The instance is considered initialized after `configure` has been called
-   * and translations for the initial language have been loaded. Can be used to
-   * show a placeholder or loading indicator until the translations are ready.
-   *
-   * Subscribers to this signal will be notified when initialization is complete
-   * and translations are ready to be used.
-   */
-  get initialized() {
-    return this.#initialized;
-  }
-  /**
-   * Returns a signal with the currently configured language.
-   *
-   * Subscribers to this signal will be notified when the language has changed
-   * and new translations have been loaded.
-   */
-  get language() {
-    return this.#language;
-  }
-  /**
-   * Returns a signal with the resolved language. The resolved language is the
-   * language that was actually used to load translations. It may differ from
-   * the configured language if there are no translations available for the
-   * configured language. For example, when setting the language to "de-DE" but
-   * translations are only available for "de", the resolved language will be
-   * "de".
-   */
-  get resolvedLanguage() {
-    return this.#resolvedLanguage;
-  }
-  /**
-   * Initializes the I18n instance. This method should be called once to load
-   * translations for the initial language. The `translate` API will not return
-   * properly translated strings until the initializations has completed.
-   *
-   * The initialization runs asynchronously as translations are loaded from the
-   * backend. The method returns a promise that resolves when the translations
-   * have been loaded, after which the `translate` API can safely be used.
-   *
-   * The initial language is determined as follows:
-   * 1. If a user opens the app for the first time, the browser language is used.
-   * 2. If the language has been changed in a previous usage of the app using
-   * `setLanguage`, the last used language is used. The last used language is
-   * automatically stored in local storage.
-   *
-   * Alternatively, the initial language can be explicitly configured using the
-   * `language` option. The language should be a valid IETF BCP 47 language tag,
-   * such as `en` or `en-US`.
-   *
-   * @param options - Optional options object to specify the initial language.
-   */
-  async configure(options) {
-    const initialLanguage = determineInitialLanguage(options);
-    await this.updateLanguage(initialLanguage);
-  }
-  /**
-   * Changes the current language and loads translations for the new language.
-   * Components using the `translate` API will automatically re-render, and
-   * subscribers to the `language` signal will be notified, when the new
-   * translations have been loaded.
-   *
-   * The language should be a valid IETF BCP 47 language tag, such as `en` or
-   * `en-US`.
-   *
-   * If there is no translation file for that specific language tag, the backend
-   * will try to load the translation file for the parent language tag. For
-   * example, if there is no translation file for `en-US`, the backend will try
-   * to load the translation file for `en`. Otherwise, it will fall back to the
-   * default translation file `translations.properties`.
-   *
-   * Changing the language is an asynchronous operation. The method returns a
-   * promise that resolves when the translations for the new language have been
-   * loaded.
-   *
-   * @param newLanguage - a valid IETF BCP 47 language tag, such as `en` or `en-US`
-   */
-  async setLanguage(newLanguage) {
-    await this.updateLanguage(newLanguage, true);
-  }
-  /**
-   * Registers the chunk name for loading translations, and loads the
-   * translations for the specified chunk.
-   *
-   * @internal only for automatic internal calls from production JS bundles
-   *
-   * @param chunkName - the production JS bundle chunk name
-   */
-  async registerChunk(chunkName) {
-    if (this.#chunks.has(chunkName)) {
-      return;
-    }
-    this.#chunks.add(chunkName);
-    if (this.#language.value) {
-      await this.updateLanguage(this.#language.value, false, chunkName);
-    }
-  }
-  async updateLanguage(newLanguage, updateSettings = false, newChunk) {
-    if (this.#language.value === newLanguage && !newChunk) {
-      return;
-    }
-    const chunks = newChunk ? [newChunk] : this.#chunks.size > 0 ? [...this.#chunks.values()] : void 0;
-    let translationsResult;
-    try {
-      translationsResult = await this.#backend.loadTranslations(newLanguage, chunks);
-    } catch (e) {
-      console.error(`Failed to load translations for language: ${newLanguage}`, e);
-      return;
-    }
-    batch(() => {
-      this.#translations.value = newChunk ? { ...this.#translations.value, ...translationsResult.translations } : translationsResult.translations;
-      this.#language.value = newLanguage;
-      this.#resolvedLanguage.value = translationsResult.resolvedLanguage;
-      this.#formatCache = new FormatCache(newLanguage);
-      this.#initialized.value = true;
-      if (updateSettings) {
-        updateLanguageSettings({
-          language: newLanguage
-        });
-      }
-    });
-  }
-  /**
-   * Reloads all translations for the current language. This method should only
-   * be used for HMR in development mode.
-   */
-  async reloadTranslations() {
-    const currentLanguage = this.#language.value;
-    if (!currentLanguage) {
-      return;
-    }
-    let translationsResult;
-    try {
-      translationsResult = await this.#backend.loadTranslations(currentLanguage);
-    } catch (e) {
-      console.error(`Failed to reload translations for language: ${currentLanguage}`, e);
-      return;
-    }
-    batch(() => {
-      this.#translations.value = translationsResult.translations;
-      this.#resolvedLanguage.value = translationsResult.resolvedLanguage;
-      this.#formatCache = new FormatCache(currentLanguage);
-    });
-  }
-  /**
-   * Returns a translated string for the given translation key. The key should
-   * match a key in the loaded translations. If no translation is found for the
-   * key, the key itself is returned.
-   *
-   * Translations may contain placeholders, following the ICU MessageFormat
-   * syntax. They can be replaced by passing a `params` object with placeholder
-   * values, where keys correspond to the placeholder names and values are the
-   * replacement value. Values should be basic types such as strings, numbers,
-   * or dates that match the placeholder format configured in the translation
-   * string. For example, when using a placeholder `{count, number}`, the value
-   * should be a number, when using `{date, date}`, the value should be a Date
-   * object, and so on.
-   *
-   * This method internally accesses a signal, meaning that React components
-   * that use it will automatically re-render when translations change.
-   * Likewise, signal effects automatically subscribe to translation changes
-   * when calling this method.
-   *
-   * @param key - The translation key to translate
-   * @param params - Optional object with placeholder values
-   */
-  translate(key, params) {
-    const translation = this.#translations.value[key];
-    if (!translation) {
-      return key;
-    }
-    const format = this.#formatCache.getFormat(translation);
-    return format.format(params);
-  }
+export class I18n {
+	#backend = new DefaultBackend();
+	#initialized = signal(false);
+	#language = signal(undefined);
+	#translations = signal({});
+	#resolvedLanguage = signal(undefined);
+	#chunks = new Set();
+	#formatCache = new FormatCache(navigator.language);
+	constructor() {
+		if (!globalThis.Vaadin?.featureFlags?.hillaI18n) {
+			throw new Error(`The Hilla I18n API is currently considered experimental and may change in the future. To use it you need to explicitly enable it in Copilot or by adding com.vaadin.experimental.hillaI18n=true to vaadin-featureflags.properties`);
+		}
+		if (import.meta.hot) {
+			import.meta.hot.on("translations-update", () => {
+				this.reloadTranslations();
+			});
+		}
+	}
+	/**
+	* Returns a signal indicating whether the I18n instance has been initialized.
+	* The instance is considered initialized after `configure` has been called
+	* and translations for the initial language have been loaded. Can be used to
+	* show a placeholder or loading indicator until the translations are ready.
+	*
+	* Subscribers to this signal will be notified when initialization is complete
+	* and translations are ready to be used.
+	*/
+	get initialized() {
+		return this.#initialized;
+	}
+	/**
+	* Returns a signal with the currently configured language.
+	*
+	* Subscribers to this signal will be notified when the language has changed
+	* and new translations have been loaded.
+	*/
+	get language() {
+		return this.#language;
+	}
+	/**
+	* Returns a signal with the resolved language. The resolved language is the
+	* language that was actually used to load translations. It may differ from
+	* the configured language if there are no translations available for the
+	* configured language. For example, when setting the language to "de-DE" but
+	* translations are only available for "de", the resolved language will be
+	* "de".
+	*/
+	get resolvedLanguage() {
+		return this.#resolvedLanguage;
+	}
+	/**
+	* Initializes the I18n instance. This method should be called once to load
+	* translations for the initial language. The `translate` API will not return
+	* properly translated strings until the initializations has completed.
+	*
+	* The initialization runs asynchronously as translations are loaded from the
+	* backend. The method returns a promise that resolves when the translations
+	* have been loaded, after which the `translate` API can safely be used.
+	*
+	* The initial language is determined as follows:
+	* 1. If a user opens the app for the first time, the browser language is used.
+	* 2. If the language has been changed in a previous usage of the app using
+	* `setLanguage`, the last used language is used. The last used language is
+	* automatically stored in local storage.
+	*
+	* Alternatively, the initial language can be explicitly configured using the
+	* `language` option. The language should be a valid IETF BCP 47 language tag,
+	* such as `en` or `en-US`.
+	*
+	* @param options - Optional options object to specify the initial language.
+	*/
+	async configure(options) {
+		const initialLanguage = determineInitialLanguage(options);
+		await this.updateLanguage(initialLanguage);
+	}
+	/**
+	* Changes the current language and loads translations for the new language.
+	* Components using the `translate` API will automatically re-render, and
+	* subscribers to the `language` signal will be notified, when the new
+	* translations have been loaded.
+	*
+	* The language should be a valid IETF BCP 47 language tag, such as `en` or
+	* `en-US`.
+	*
+	* If there is no translation file for that specific language tag, the backend
+	* will try to load the translation file for the parent language tag. For
+	* example, if there is no translation file for `en-US`, the backend will try
+	* to load the translation file for `en`. Otherwise, it will fall back to the
+	* default translation file `translations.properties`.
+	*
+	* Changing the language is an asynchronous operation. The method returns a
+	* promise that resolves when the translations for the new language have been
+	* loaded.
+	*
+	* @param newLanguage - a valid IETF BCP 47 language tag, such as `en` or `en-US`
+	*/
+	async setLanguage(newLanguage) {
+		await this.updateLanguage(newLanguage, true);
+	}
+	/**
+	* Registers the chunk name for loading translations, and loads the
+	* translations for the specified chunk.
+	*
+	* @internal only for automatic internal calls from production JS bundles
+	*
+	* @param chunkName - the production JS bundle chunk name
+	*/
+	async registerChunk(chunkName) {
+		if (this.#chunks.has(chunkName)) {
+			return;
+		}
+		this.#chunks.add(chunkName);
+		if (this.#language.value) {
+			await this.updateLanguage(this.#language.value, false, chunkName);
+		}
+	}
+	async updateLanguage(newLanguage, updateSettings = false, newChunk) {
+		if (this.#language.value === newLanguage && !newChunk) {
+			return;
+		}
+		const chunks = newChunk ? [newChunk] : this.#chunks.size > 0 ? [...this.#chunks.values()] : undefined;
+		let translationsResult;
+		try {
+			translationsResult = await this.#backend.loadTranslations(newLanguage, chunks);
+		} catch (e) {
+			console.error(`Failed to load translations for language: ${newLanguage}`, e);
+			return;
+		}
+		batch(() => {
+			this.#translations.value = newChunk ? {
+				...this.#translations.value,
+				...translationsResult.translations
+			} : translationsResult.translations;
+			this.#language.value = newLanguage;
+			this.#resolvedLanguage.value = translationsResult.resolvedLanguage;
+			this.#formatCache = new FormatCache(newLanguage);
+			this.#initialized.value = true;
+			if (updateSettings) {
+				updateLanguageSettings({ language: newLanguage });
+			}
+		});
+	}
+	/**
+	* Reloads all translations for the current language. This method should only
+	* be used for HMR in development mode.
+	*/
+	async reloadTranslations() {
+		const currentLanguage = this.#language.value;
+		if (!currentLanguage) {
+			return;
+		}
+		let translationsResult;
+		try {
+			translationsResult = await this.#backend.loadTranslations(currentLanguage);
+		} catch (e) {
+			console.error(`Failed to reload translations for language: ${currentLanguage}`, e);
+			return;
+		}
+		batch(() => {
+			this.#translations.value = translationsResult.translations;
+			this.#resolvedLanguage.value = translationsResult.resolvedLanguage;
+			this.#formatCache = new FormatCache(currentLanguage);
+		});
+	}
+	/**
+	* Returns a translated string for the given translation key. The key should
+	* match a key in the loaded translations. If no translation is found for the
+	* key, the key itself is returned.
+	*
+	* Translations may contain placeholders, following the ICU MessageFormat
+	* syntax. They can be replaced by passing a `params` object with placeholder
+	* values, where keys correspond to the placeholder names and values are the
+	* replacement value. Values should be basic types such as strings, numbers,
+	* or dates that match the placeholder format configured in the translation
+	* string. For example, when using a placeholder `{count, number}`, the value
+	* should be a number, when using `{date, date}`, the value should be a Date
+	* object, and so on.
+	*
+	* This method internally accesses a signal, meaning that React components
+	* that use it will automatically re-render when translations change.
+	* Likewise, signal effects automatically subscribe to translation changes
+	* when calling this method.
+	*
+	* @param key - The translation key to translate
+	* @param params - Optional object with placeholder values
+	*/
+	translate(key, params) {
+		const translation = this.#translations.value[key];
+		if (!translation) {
+			return key;
+		}
+		const format = this.#formatCache.getFormat(translation);
+		return format.format(params);
+	}
 }
-const i18n = new I18n();
-function translate(key, params) {
-  return i18n.translate(key, params);
+/**
+* The global I18n instance that is used to initialize translations, change the
+* current language, and translate strings.
+*/
+export const i18n = new I18n();
+/**
+* Returns a translated string for the given translation key. The key should
+* match a key in the loaded translations. If no translation is found for the
+* key, the key itself is returned.
+*
+* Translations may contain placeholders, following the ICU MessageFormat
+* syntax. They can be replaced by passing a `params` object with placeholder
+* values, where keys correspond to the placeholder names and values are the
+* replacement value. Values should be basic types such as strings, numbers,
+* or dates that match the placeholder format configured in the translation
+* string. For example, when using a placeholder `{count, number}`, the value
+* should be a number, when using `{date, date}`, the value should be a Date
+* object, and so on.
+*
+* This method internally accesses a signal, meaning that React components
+* that use it will automatically re-render when translations change.
+* Likewise, signal effects automatically subscribe to translation changes
+* when calling this method.
+*
+* This function is a shorthand for `i18n.translate` of the global I18n instance.
+*
+* @param key - The translation key to translate
+* @param params - Optional object with placeholder values
+*/ export function translate(key, params) {
+	return i18n.translate(key, params);
 }
-export {
-  I18n,
-  i18n,
-  translate
-};
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=./index.js.map

package/index.js.map

@@ -1,7 +1 @@
-{
-  "version": 3,
-  "sources": ["src/index.ts"],
-  "sourcesContent": ["import { batch, type ReadonlySignal, signal, type Signal } from '@vaadin/hilla-react-signals';\nimport { DefaultBackend, type I18nBackend } from './backend.js';\nimport { FormatCache } from './FormatCache.js';\nimport { getLanguageSettings, updateLanguageSettings } from './settings.js';\nimport type { I18nOptions, Translations, TranslationsResult } from './types.js';\n\ninterface VaadinGlobal {\n  Vaadin?: {\n    featureFlags?: {\n      hillaI18n?: boolean;\n    };\n  };\n}\n\nfunction determineInitialLanguage(options?: I18nOptions): string {\n  // Use explicitly configured language if defined\n  if (options?.language) {\n    return options.language;\n  }\n  // Use last used language as fallback\n  const settings = getLanguageSettings();\n  if (settings?.language) {\n    return settings.language;\n  }\n  // Otherwise use browser language\n  return navigator.language;\n}\n\nexport class I18n {\n  readonly #backend: I18nBackend = new DefaultBackend();\n\n  readonly #initialized: Signal<boolean> = signal(false);\n  readonly #language: Signal<string | undefined> = signal(undefined);\n  readonly #translations: Signal<Translations> = signal({});\n  readonly #resolvedLanguage: Signal<string | undefined> = signal(undefined);\n  readonly #chunks = new Set<string>();\n\n  #formatCache: FormatCache = new FormatCache(navigator.language);\n\n  constructor() {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    if (!(globalThis as VaadinGlobal).Vaadin?.featureFlags?.hillaI18n) {\n      // Remove when removing feature flag\n      throw new Error(\n        `The Hilla I18n API is currently considered experimental and may change in the future. To use it you need to explicitly enable it in Copilot or by adding com.vaadin.experimental.hillaI18n=true to vaadin-featureflags.properties`,\n      );\n    }\n    // @ts-expect-error import.meta.hot does not have TS definitions\n    if (import.meta.hot) {\n      // @ts-expect-error import.meta.hot does not have TS definitions\n      // eslint-disable-next-line\n      import.meta.hot.on('translations-update', () => {\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        this.reloadTranslations();\n      });\n    }\n  }\n\n  /**\n   * Returns a signal indicating whether the I18n instance has been initialized.\n   * The instance is considered initialized after `configure` has been called\n   * and translations for the initial language have been loaded. Can be used to\n   * show a placeholder or loading indicator until the translations are ready.\n   *\n   * Subscribers to this signal will be notified when initialization is complete\n   * and translations are ready to be used.\n   */\n  get initialized(): ReadonlySignal<boolean> {\n    return this.#initialized;\n  }\n\n  /**\n   * Returns a signal with the currently configured language.\n   *\n   * Subscribers to this signal will be notified when the language has changed\n   * and new translations have been loaded.\n   */\n  get language(): ReadonlySignal<string | undefined> {\n    return this.#language;\n  }\n\n  /**\n   * Returns a signal with the resolved language. The resolved language is the\n   * language that was actually used to load translations. It may differ from\n   * the configured language if there are no translations available for the\n   * configured language. For example, when setting the language to \"de-DE\" but\n   * translations are only available for \"de\", the resolved language will be\n   * \"de\".\n   */\n  get resolvedLanguage(): ReadonlySignal<string | undefined> {\n    return this.#resolvedLanguage;\n  }\n\n  /**\n   * Initializes the I18n instance. This method should be called once to load\n   * translations for the initial language. The `translate` API will not return\n   * properly translated strings until the initializations has completed.\n   *\n   * The initialization runs asynchronously as translations are loaded from the\n   * backend. The method returns a promise that resolves when the translations\n   * have been loaded, after which the `translate` API can safely be used.\n   *\n   * The initial language is determined as follows:\n   * 1. If a user opens the app for the first time, the browser language is used.\n   * 2. If the language has been changed in a previous usage of the app using\n   * `setLanguage`, the last used language is used. The last used language is\n   * automatically stored in local storage.\n   *\n   * Alternatively, the initial language can be explicitly configured using the\n   * `language` option. The language should be a valid IETF BCP 47 language tag,\n   * such as `en` or `en-US`.\n   *\n   * @param options - Optional options object to specify the initial language.\n   */\n  async configure(options?: I18nOptions): Promise<void> {\n    const initialLanguage = determineInitialLanguage(options);\n    await this.updateLanguage(initialLanguage);\n  }\n\n  /**\n   * Changes the current language and loads translations for the new language.\n   * Components using the `translate` API will automatically re-render, and\n   * subscribers to the `language` signal will be notified, when the new\n   * translations have been loaded.\n   *\n   * The language should be a valid IETF BCP 47 language tag, such as `en` or\n   * `en-US`.\n   *\n   * If there is no translation file for that specific language tag, the backend\n   * will try to load the translation file for the parent language tag. For\n   * example, if there is no translation file for `en-US`, the backend will try\n   * to load the translation file for `en`. Otherwise, it will fall back to the\n   * default translation file `translations.properties`.\n   *\n   * Changing the language is an asynchronous operation. The method returns a\n   * promise that resolves when the translations for the new language have been\n   * loaded.\n   *\n   * @param newLanguage - a valid IETF BCP 47 language tag, such as `en` or `en-US`\n   */\n  async setLanguage(newLanguage: string): Promise<void> {\n    await this.updateLanguage(newLanguage, true);\n  }\n\n  /**\n   * Registers the chunk name for loading translations, and loads the\n   * translations for the specified chunk.\n   *\n   * @internal only for automatic internal calls from production JS bundles\n   *\n   * @param chunkName - the production JS bundle chunk name\n   */\n  async registerChunk(chunkName: string): Promise<void> {\n    if (this.#chunks.has(chunkName)) {\n      return;\n    }\n\n    this.#chunks.add(chunkName);\n\n    if (this.#language.value) {\n      await this.updateLanguage(this.#language.value, false, chunkName);\n    }\n  }\n\n  private async updateLanguage(newLanguage: string, updateSettings = false, newChunk?: string) {\n    if (this.#language.value === newLanguage && !newChunk) {\n      return;\n    }\n\n    const chunks = newChunk\n      ? [newChunk] // New chunk is registered, load only that\n      : this.#chunks.size > 0\n        ? [...this.#chunks.values()] // Load the new language for all chunks registered so far\n        : undefined; // Load the new language without specifying chunks, assuming dev. mode\n\n    let translationsResult: TranslationsResult;\n    try {\n      translationsResult = await this.#backend.loadTranslations(newLanguage, chunks);\n    } catch (e) {\n      console.error(`Failed to load translations for language: ${newLanguage}`, e);\n      return;\n    }\n\n    // Update all signals together to avoid triggering side effects multiple times\n    batch(() => {\n      this.#translations.value = newChunk\n        ? { ...this.#translations.value, ...translationsResult.translations }\n        : translationsResult.translations;\n      this.#language.value = newLanguage;\n      this.#resolvedLanguage.value = translationsResult.resolvedLanguage;\n      this.#formatCache = new FormatCache(newLanguage);\n      this.#initialized.value = true;\n\n      if (updateSettings) {\n        updateLanguageSettings({\n          language: newLanguage,\n        });\n      }\n    });\n  }\n\n  /**\n   * Reloads all translations for the current language. This method should only\n   * be used for HMR in development mode.\n   */\n  private async reloadTranslations() {\n    const currentLanguage = this.#language.value;\n    if (!currentLanguage) {\n      return;\n    }\n\n    let translationsResult: TranslationsResult;\n    try {\n      translationsResult = await this.#backend.loadTranslations(currentLanguage);\n    } catch (e) {\n      console.error(`Failed to reload translations for language: ${currentLanguage}`, e);\n      return;\n    }\n\n    // Update all signals together to avoid triggering side effects multiple times\n    batch(() => {\n      this.#translations.value = translationsResult.translations;\n      this.#resolvedLanguage.value = translationsResult.resolvedLanguage;\n      this.#formatCache = new FormatCache(currentLanguage);\n    });\n  }\n\n  /**\n   * Returns a translated string for the given translation key. The key should\n   * match a key in the loaded translations. If no translation is found for the\n   * key, the key itself is returned.\n   *\n   * Translations may contain placeholders, following the ICU MessageFormat\n   * syntax. They can be replaced by passing a `params` object with placeholder\n   * values, where keys correspond to the placeholder names and values are the\n   * replacement value. Values should be basic types such as strings, numbers,\n   * or dates that match the placeholder format configured in the translation\n   * string. For example, when using a placeholder `{count, number}`, the value\n   * should be a number, when using `{date, date}`, the value should be a Date\n   * object, and so on.\n   *\n   * This method internally accesses a signal, meaning that React components\n   * that use it will automatically re-render when translations change.\n   * Likewise, signal effects automatically subscribe to translation changes\n   * when calling this method.\n   *\n   * @param key - The translation key to translate\n   * @param params - Optional object with placeholder values\n   */\n  translate(key: string, params?: Record<string, unknown>): string {\n    const translation = this.#translations.value[key];\n    if (!translation) {\n      return key;\n    }\n    const format = this.#formatCache.getFormat(translation);\n    return format.format(params) as string;\n  }\n}\n\n/**\n * The global I18n instance that is used to initialize translations, change the\n * current language, and translate strings.\n */\nexport const i18n = new I18n();\n\n/**\n * Returns a translated string for the given translation key. The key should\n * match a key in the loaded translations. If no translation is found for the\n * key, the key itself is returned.\n *\n * Translations may contain placeholders, following the ICU MessageFormat\n * syntax. They can be replaced by passing a `params` object with placeholder\n * values, where keys correspond to the placeholder names and values are the\n * replacement value. Values should be basic types such as strings, numbers,\n * or dates that match the placeholder format configured in the translation\n * string. For example, when using a placeholder `{count, number}`, the value\n * should be a number, when using `{date, date}`, the value should be a Date\n * object, and so on.\n *\n * This method internally accesses a signal, meaning that React components\n * that use it will automatically re-render when translations change.\n * Likewise, signal effects automatically subscribe to translation changes\n * when calling this method.\n *\n * This function is a shorthand for `i18n.translate` of the global I18n instance.\n *\n * @param key - The translation key to translate\n * @param params - Optional object with placeholder values\n */ export function translate(key: string, params?: Record<string, unknown>): string {\n  return i18n.translate(key, params);\n}\n"],
-  "mappings": "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",
-  "names": []
-}
+{"mappings":"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","names":["options?: I18nOptions","#backend","#initialized","#language","#translations","#resolvedLanguage","#chunks","newLanguage: string","chunkName: string","newChunk?: string","translationsResult: TranslationsResult","#formatCache","key: string","params?: Record<string, unknown>","i18n: I18n"],"sources":["/opt/agent/work/1af72d8adc613024/hilla/packages/ts/react-i18n/src/index.ts"],"sourcesContent":["import { batch, type ReadonlySignal, signal, type Signal } from '@vaadin/hilla-react-signals';\nimport { DefaultBackend, type I18nBackend } from './backend.js';\nimport { FormatCache } from './FormatCache.js';\nimport { getLanguageSettings, updateLanguageSettings } from './settings.js';\nimport type { I18nOptions, Translations, TranslationsResult } from './types.js';\n\ninterface VaadinGlobal {\n  Vaadin?: {\n    featureFlags?: {\n      hillaI18n?: boolean;\n    };\n  };\n}\n\nfunction determineInitialLanguage(options?: I18nOptions): string {\n  // Use explicitly configured language if defined\n  if (options?.language) {\n    return options.language;\n  }\n  // Use last used language as fallback\n  const settings = getLanguageSettings();\n  if (settings?.language) {\n    return settings.language;\n  }\n  // Otherwise use browser language\n  return navigator.language;\n}\n\nexport class I18n {\n  readonly #backend: I18nBackend = new DefaultBackend();\n\n  readonly #initialized: Signal<boolean> = signal(false);\n  readonly #language: Signal<string | undefined> = signal(undefined);\n  readonly #translations: Signal<Translations> = signal({});\n  readonly #resolvedLanguage: Signal<string | undefined> = signal(undefined);\n  readonly #chunks = new Set<string>();\n\n  #formatCache: FormatCache = new FormatCache(navigator.language);\n\n  constructor() {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    if (!(globalThis as VaadinGlobal).Vaadin?.featureFlags?.hillaI18n) {\n      // Remove when removing feature flag\n      throw new Error(\n        `The Hilla I18n API is currently considered experimental and may change in the future. To use it you need to explicitly enable it in Copilot or by adding com.vaadin.experimental.hillaI18n=true to vaadin-featureflags.properties`,\n      );\n    }\n    // @ts-expect-error import.meta.hot does not have TS definitions\n    if (import.meta.hot) {\n      // @ts-expect-error import.meta.hot does not have TS definitions\n      // eslint-disable-next-line\n      import.meta.hot.on('translations-update', () => {\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        this.reloadTranslations();\n      });\n    }\n  }\n\n  /**\n   * Returns a signal indicating whether the I18n instance has been initialized.\n   * The instance is considered initialized after `configure` has been called\n   * and translations for the initial language have been loaded. Can be used to\n   * show a placeholder or loading indicator until the translations are ready.\n   *\n   * Subscribers to this signal will be notified when initialization is complete\n   * and translations are ready to be used.\n   */\n  get initialized(): ReadonlySignal<boolean> {\n    return this.#initialized;\n  }\n\n  /**\n   * Returns a signal with the currently configured language.\n   *\n   * Subscribers to this signal will be notified when the language has changed\n   * and new translations have been loaded.\n   */\n  get language(): ReadonlySignal<string | undefined> {\n    return this.#language;\n  }\n\n  /**\n   * Returns a signal with the resolved language. The resolved language is the\n   * language that was actually used to load translations. It may differ from\n   * the configured language if there are no translations available for the\n   * configured language. For example, when setting the language to \"de-DE\" but\n   * translations are only available for \"de\", the resolved language will be\n   * \"de\".\n   */\n  get resolvedLanguage(): ReadonlySignal<string | undefined> {\n    return this.#resolvedLanguage;\n  }\n\n  /**\n   * Initializes the I18n instance. This method should be called once to load\n   * translations for the initial language. The `translate` API will not return\n   * properly translated strings until the initializations has completed.\n   *\n   * The initialization runs asynchronously as translations are loaded from the\n   * backend. The method returns a promise that resolves when the translations\n   * have been loaded, after which the `translate` API can safely be used.\n   *\n   * The initial language is determined as follows:\n   * 1. If a user opens the app for the first time, the browser language is used.\n   * 2. If the language has been changed in a previous usage of the app using\n   * `setLanguage`, the last used language is used. The last used language is\n   * automatically stored in local storage.\n   *\n   * Alternatively, the initial language can be explicitly configured using the\n   * `language` option. The language should be a valid IETF BCP 47 language tag,\n   * such as `en` or `en-US`.\n   *\n   * @param options - Optional options object to specify the initial language.\n   */\n  async configure(options?: I18nOptions): Promise<void> {\n    const initialLanguage = determineInitialLanguage(options);\n    await this.updateLanguage(initialLanguage);\n  }\n\n  /**\n   * Changes the current language and loads translations for the new language.\n   * Components using the `translate` API will automatically re-render, and\n   * subscribers to the `language` signal will be notified, when the new\n   * translations have been loaded.\n   *\n   * The language should be a valid IETF BCP 47 language tag, such as `en` or\n   * `en-US`.\n   *\n   * If there is no translation file for that specific language tag, the backend\n   * will try to load the translation file for the parent language tag. For\n   * example, if there is no translation file for `en-US`, the backend will try\n   * to load the translation file for `en`. Otherwise, it will fall back to the\n   * default translation file `translations.properties`.\n   *\n   * Changing the language is an asynchronous operation. The method returns a\n   * promise that resolves when the translations for the new language have been\n   * loaded.\n   *\n   * @param newLanguage - a valid IETF BCP 47 language tag, such as `en` or `en-US`\n   */\n  async setLanguage(newLanguage: string): Promise<void> {\n    await this.updateLanguage(newLanguage, true);\n  }\n\n  /**\n   * Registers the chunk name for loading translations, and loads the\n   * translations for the specified chunk.\n   *\n   * @internal only for automatic internal calls from production JS bundles\n   *\n   * @param chunkName - the production JS bundle chunk name\n   */\n  async registerChunk(chunkName: string): Promise<void> {\n    if (this.#chunks.has(chunkName)) {\n      return;\n    }\n\n    this.#chunks.add(chunkName);\n\n    if (this.#language.value) {\n      await this.updateLanguage(this.#language.value, false, chunkName);\n    }\n  }\n\n  private async updateLanguage(newLanguage: string, updateSettings = false, newChunk?: string) {\n    if (this.#language.value === newLanguage && !newChunk) {\n      return;\n    }\n\n    const chunks = newChunk\n      ? [newChunk] // New chunk is registered, load only that\n      : this.#chunks.size > 0\n        ? [...this.#chunks.values()] // Load the new language for all chunks registered so far\n        : undefined; // Load the new language without specifying chunks, assuming dev. mode\n\n    let translationsResult: TranslationsResult;\n    try {\n      translationsResult = await this.#backend.loadTranslations(newLanguage, chunks);\n    } catch (e) {\n      console.error(`Failed to load translations for language: ${newLanguage}`, e);\n      return;\n    }\n\n    // Update all signals together to avoid triggering side effects multiple times\n    batch(() => {\n      this.#translations.value = newChunk\n        ? { ...this.#translations.value, ...translationsResult.translations }\n        : translationsResult.translations;\n      this.#language.value = newLanguage;\n      this.#resolvedLanguage.value = translationsResult.resolvedLanguage;\n      this.#formatCache = new FormatCache(newLanguage);\n      this.#initialized.value = true;\n\n      if (updateSettings) {\n        updateLanguageSettings({\n          language: newLanguage,\n        });\n      }\n    });\n  }\n\n  /**\n   * Reloads all translations for the current language. This method should only\n   * be used for HMR in development mode.\n   */\n  private async reloadTranslations() {\n    const currentLanguage = this.#language.value;\n    if (!currentLanguage) {\n      return;\n    }\n\n    let translationsResult: TranslationsResult;\n    try {\n      translationsResult = await this.#backend.loadTranslations(currentLanguage);\n    } catch (e) {\n      console.error(`Failed to reload translations for language: ${currentLanguage}`, e);\n      return;\n    }\n\n    // Update all signals together to avoid triggering side effects multiple times\n    batch(() => {\n      this.#translations.value = translationsResult.translations;\n      this.#resolvedLanguage.value = translationsResult.resolvedLanguage;\n      this.#formatCache = new FormatCache(currentLanguage);\n    });\n  }\n\n  /**\n   * Returns a translated string for the given translation key. The key should\n   * match a key in the loaded translations. If no translation is found for the\n   * key, the key itself is returned.\n   *\n   * Translations may contain placeholders, following the ICU MessageFormat\n   * syntax. They can be replaced by passing a `params` object with placeholder\n   * values, where keys correspond to the placeholder names and values are the\n   * replacement value. Values should be basic types such as strings, numbers,\n   * or dates that match the placeholder format configured in the translation\n   * string. For example, when using a placeholder `{count, number}`, the value\n   * should be a number, when using `{date, date}`, the value should be a Date\n   * object, and so on.\n   *\n   * This method internally accesses a signal, meaning that React components\n   * that use it will automatically re-render when translations change.\n   * Likewise, signal effects automatically subscribe to translation changes\n   * when calling this method.\n   *\n   * @param key - The translation key to translate\n   * @param params - Optional object with placeholder values\n   */\n  translate(key: string, params?: Record<string, unknown>): string {\n    const translation = this.#translations.value[key];\n    if (!translation) {\n      return key;\n    }\n    const format = this.#formatCache.getFormat(translation);\n    return format.format(params) as string;\n  }\n}\n\n/**\n * The global I18n instance that is used to initialize translations, change the\n * current language, and translate strings.\n */\nexport const i18n: I18n = new I18n();\n\n/**\n * Returns a translated string for the given translation key. The key should\n * match a key in the loaded translations. If no translation is found for the\n * key, the key itself is returned.\n *\n * Translations may contain placeholders, following the ICU MessageFormat\n * syntax. They can be replaced by passing a `params` object with placeholder\n * values, where keys correspond to the placeholder names and values are the\n * replacement value. Values should be basic types such as strings, numbers,\n * or dates that match the placeholder format configured in the translation\n * string. For example, when using a placeholder `{count, number}`, the value\n * should be a number, when using `{date, date}`, the value should be a Date\n * object, and so on.\n *\n * This method internally accesses a signal, meaning that React components\n * that use it will automatically re-render when translations change.\n * Likewise, signal effects automatically subscribe to translation changes\n * when calling this method.\n *\n * This function is a shorthand for `i18n.translate` of the global I18n instance.\n *\n * @param key - The translation key to translate\n * @param params - Optional object with placeholder values\n */ export function translate(key: string, params?: Record<string, unknown>): string {\n  return i18n.translate(key, params);\n}\n"],"version":3}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vaadin/hilla-react-i18n",
-  "version": "24.7.0-alpha9",
+  "version": "24.7.0-beta3",
   "description": "Hilla I18n utils for React",
   "main": "index.js",
   "module": "index.js",
@@ -17,15 +17,13 @@
   ],
   "scripts": {
     "clean:build": "git clean -fx . -e .vite -e node_modules",
-    "build": "concurrently npm:build:*",
-    "build:esbuild": "tsx ../../../scripts/build.ts",
-    "build:dts": "tsc --isolatedModules -p tsconfig.build.json",
-    "build:copy": "cd src && copyfiles **/*.d.ts ..",
+    "build": "tsx ../../../scripts/fast-build.ts",
     "lint": "eslint src test",
     "lint:fix": "eslint src test --fix",
-    "test": "karma start ../../../karma.config.cjs --port 9878",
-    "test:coverage": "npm run test -- --coverage",
-    "test:watch": "npm run test -- --watch",
+    "test": "vitest --run",
+    "test:coverage": "vitest --run --coverage",
+    "test:react": "npm run test",
+    "test:watch": "vitest",
     "typecheck": "tsc --noEmit"
   },
   "exports": {
@@ -46,33 +44,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@vaadin/hilla-frontend": "24.7.0-alpha9",
-    "@vaadin/hilla-react-signals": "24.7.0-alpha9",
-    "intl-messageformat": "^10.7.11"
+    "@vaadin/hilla-frontend": "24.7.0-beta3",
+    "@vaadin/hilla-react-signals": "24.7.0-beta3",
+    "intl-messageformat": "10.7.11"
   },
   "peerDependencies": {
     "react": "18 || 19",
     "react-dom": "18 || 19"
-  },
-  "devDependencies": {
-    "@testing-library/dom": "^10.4.0",
-    "@testing-library/react": "^16.1.0",
-    "@testing-library/user-event": "^14.5.2",
-    "@types/chai": "^4.3.20",
-    "@types/chai-as-promised": "^7.1.8",
-    "@types/chai-dom": "^1.11.3",
-    "@types/mocha": "^10.0.10",
-    "@types/react": "^18.3.18",
-    "@types/react-dom": "^18",
-    "@types/sinon": "^10.0.20",
-    "@types/sinon-chai": "^3.2.12",
-    "@types/validator": "^13.12.2",
-    "chai": "^5.1.2",
-    "chai-as-promised": "^7.1.2",
-    "chai-dom": "^1.12.0",
-    "fetch-mock": "^9.11.0",
-    "sinon": "^16.1.3",
-    "sinon-chai": "^3.7.0",
-    "typescript": "5.7.3"
   }
 }

package/settings.d.ts

@@ -1,7 +1,6 @@
 export declare const VAADIN_LANGUAGE_SETTINGS_COOKIE_NAME = "vaadinLanguageSettings";
 export interface LanguageSettings {
-    language?: string;
+	language?: string;
 }
 export declare function getLanguageSettings(): LanguageSettings | undefined;
 export declare function updateLanguageSettings(updates: Partial<LanguageSettings>): void;
-//# sourceMappingURL=settings.d.ts.map

package/settings.js

@@ -1,26 +1,23 @@
 import CookieManager from "@vaadin/hilla-frontend/CookieManager.js";
-const VAADIN_LANGUAGE_SETTINGS_COOKIE_NAME = "vaadinLanguageSettings";
-function getLanguageSettings() {
-  const cookie = CookieManager.get(VAADIN_LANGUAGE_SETTINGS_COOKIE_NAME);
-  if (!cookie) return void 0;
-  try {
-    return JSON.parse(cookie);
-  } catch (e) {
-    return void 0;
-  }
+export const VAADIN_LANGUAGE_SETTINGS_COOKIE_NAME = "vaadinLanguageSettings";
+export function getLanguageSettings() {
+	const cookie = CookieManager.get(VAADIN_LANGUAGE_SETTINGS_COOKIE_NAME);
+	if (!cookie) {
+		return undefined;
+	}
+	try {
+		return JSON.parse(cookie);
+	} catch {
+		return undefined;
+	}
 }
-function updateLanguageSettings(updates) {
-  const settings = getLanguageSettings() ?? {};
-  const newSettings = {
-    ...settings,
-    ...updates
-  };
-  const json = JSON.stringify(newSettings);
-  CookieManager.set(VAADIN_LANGUAGE_SETTINGS_COOKIE_NAME, json);
+export function updateLanguageSettings(updates) {
+	const settings = getLanguageSettings() ?? {};
+	const newSettings = {
+		...settings,
+		...updates
+	};
+	const json = JSON.stringify(newSettings);
+	CookieManager.set(VAADIN_LANGUAGE_SETTINGS_COOKIE_NAME, json);
 }
-export {
-  VAADIN_LANGUAGE_SETTINGS_COOKIE_NAME,
-  getLanguageSettings,
-  updateLanguageSettings
-};
-//# sourceMappingURL=settings.js.map
+//# sourceMappingURL=./settings.js.map

package/settings.js.map

@@ -1,7 +1 @@
-{
-  "version": 3,
-  "sources": ["src/settings.ts"],
-  "sourcesContent": ["import CookieManager from '@vaadin/hilla-frontend/CookieManager.js';\n\nexport const VAADIN_LANGUAGE_SETTINGS_COOKIE_NAME = 'vaadinLanguageSettings';\n\nexport interface LanguageSettings {\n  language?: string;\n}\n\nexport function getLanguageSettings(): LanguageSettings | undefined {\n  const cookie = CookieManager.get(VAADIN_LANGUAGE_SETTINGS_COOKIE_NAME);\n  if (!cookie) return undefined;\n\n  try {\n    return JSON.parse(cookie);\n  } catch (e) {\n    // Ignore\n    return undefined;\n  }\n}\n\nexport function updateLanguageSettings(updates: Partial<LanguageSettings>): void {\n  const settings = getLanguageSettings() ?? {};\n  const newSettings = {\n    ...settings,\n    ...updates,\n  };\n  const json = JSON.stringify(newSettings);\n  CookieManager.set(VAADIN_LANGUAGE_SETTINGS_COOKIE_NAME, json);\n}\n"],
-  "mappings": "AAAA,OAAO,mBAAmB;AAEnB,MAAM,uCAAuC;AAM7C,SAAS,sBAAoD;AAClE,QAAM,SAAS,cAAc,IAAI,oCAAoC;AACrE,MAAI,CAAC,OAAQ,QAAO;AAEpB,MAAI;AACF,WAAO,KAAK,MAAM,MAAM;AAAA,EAC1B,SAAS,GAAG;AAEV,WAAO;AAAA,EACT;AACF;AAEO,SAAS,uBAAuB,SAA0C;AAC/E,QAAM,WAAW,oBAAoB,KAAK,CAAC;AAC3C,QAAM,cAAc;AAAA,IAClB,GAAG;AAAA,IACH,GAAG;AAAA,EACL;AACA,QAAM,OAAO,KAAK,UAAU,WAAW;AACvC,gBAAc,IAAI,sCAAsC,IAAI;AAC9D;",
-  "names": []
-}
+{"mappings":"AAAA,OAAO,4DAA6D;AAEpE,OAAO,MAAM,uCAAuC;AAMpD,OAAO,SAAS,sBAAoD;CAClE,MAAM,SAAS,cAAc,IAAI,qCAAqC;AACtE,MAAK,QAAQ;AACX,SAAO;CACR;AAED,KAAI;AACF,SAAO,KAAK,MAAM,OAAO;CAC1B,QAAO;AAEN,SAAO;CACR;AACF;AAED,OAAO,SAAS,uBAAuBA,SAA0C;CAC/E,MAAM,WAAW,qBAAqB,IAAI,CAAE;CAC5C,MAAM,cAAc;EAClB,GAAG;EACH,GAAG;CACJ;CACD,MAAM,OAAO,KAAK,UAAU,YAAY;AACxC,eAAc,IAAI,sCAAsC,KAAK;AAC9D","names":["updates: Partial<LanguageSettings>"],"sources":["/opt/agent/work/1af72d8adc613024/hilla/packages/ts/react-i18n/src/settings.ts"],"sourcesContent":["import CookieManager from '@vaadin/hilla-frontend/CookieManager.js';\n\nexport const VAADIN_LANGUAGE_SETTINGS_COOKIE_NAME = 'vaadinLanguageSettings';\n\nexport interface LanguageSettings {\n  language?: string;\n}\n\nexport function getLanguageSettings(): LanguageSettings | undefined {\n  const cookie = CookieManager.get(VAADIN_LANGUAGE_SETTINGS_COOKIE_NAME);\n  if (!cookie) {\n    return undefined;\n  }\n\n  try {\n    return JSON.parse(cookie);\n  } catch {\n    // Ignore\n    return undefined;\n  }\n}\n\nexport function updateLanguageSettings(updates: Partial<LanguageSettings>): void {\n  const settings = getLanguageSettings() ?? {};\n  const newSettings = {\n    ...settings,\n    ...updates,\n  };\n  const json = JSON.stringify(newSettings);\n  CookieManager.set(VAADIN_LANGUAGE_SETTINGS_COOKIE_NAME, json);\n}\n"],"version":3}

package/types.d.ts

@@ -1,13 +1,12 @@
 export type Translations = Readonly<Record<string, string>>;
 export type TranslationsResult = Readonly<{
-    translations: Translations;
-    resolvedLanguage?: string;
+	translations: Translations
+	resolvedLanguage?: string
 }>;
 export interface I18nOptions {
-    /**
-     * Allows to explicitly set the initial language. Should be a valid
-     * IETF BCP 47 language tag, such as `en` or `en-US`
-     */
-    language?: string;
+	/**
+	* Allows to explicitly set the initial language. Should be a valid
+	* IETF BCP 47 language tag, such as `en` or `en-US`
+	*/
+	language?: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/FormatCache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FormatCache.d.ts","sourceRoot":"","sources":["src/FormatCache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD,qBAAa,WAAW;;gBAIV,QAAQ,EAAE,MAAM;IAU5B,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,iBAAiB;CAQlD"}

package/backend.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["src/backend.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEnE,MAAM,WAAW,WAAW;IAC1B,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAC7F;AAED,qBAAa,cAAe,YAAW,WAAW;IAC1C,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAiBlG"}

package/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,cAAc,EAAuB,MAAM,6BAA6B,CAAC;AAI9F,OAAO,KAAK,EAAE,WAAW,EAAoC,MAAM,YAAY,CAAC;AAwBhF,qBAAa,IAAI;;;IA8Bf;;;;;;;;OAQG;IACH,IAAI,WAAW,IAAI,cAAc,CAAC,OAAO,CAAC,CAEzC;IAED;;;;;OAKG;IACH,IAAI,QAAQ,IAAI,cAAc,CAAC,MAAM,GAAG,SAAS,CAAC,CAEjD;IAED;;;;;;;OAOG;IACH,IAAI,gBAAgB,IAAI,cAAc,CAAC,MAAM,GAAG,SAAS,CAAC,CAEzD;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,SAAS,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAKrD;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrD;;;;;;;OAOG;IACG,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAYvC,cAAc;IAqC5B;;;OAGG;YACW,kBAAkB;IAsBhC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;CAQjE;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,MAAa,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;;;;;GAuBG,CAAC,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAEnF"}

package/settings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["src/settings.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oCAAoC,2BAA2B,CAAC;AAE7E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,mBAAmB,IAAI,gBAAgB,GAAG,SAAS,CAUlE;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAQ/E"}

package/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAE5D,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACxC,YAAY,EAAE,YAAY,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC,CAAC;AAEH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB"}

package/types.js

@@ -1 +0,0 @@
-//# sourceMappingURL=types.js.map

package/types.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": [],
-  "sourcesContent": [],
-  "mappings": "",
-  "names": []
-}