vanilla-intlayer 8.8.0 → 8.9.0

package/dist/esm/client/index.mjs

@@ -1,8 +1,9 @@
-import { i as e, n as t, r as n, t as r } from "../../installIntlayer-C99qMzFH.mjs";
-import { useDictionary as i } from "./useDictionary.mjs";
-import { useDictionaryDynamic as a } from "./useDictionaryDynamic.mjs";
-import { useIntlayer as o } from "./useIntlayer.mjs";
-import { localeCookie as s, localeInStorage as c, setLocaleCookie as l, setLocaleInStorage as u, useLocaleCookie as d, useLocaleStorage as f } from "./useLocaleStorage.mjs";
-import { useLocale as p } from "./useLocale.mjs";
-import { useRewriteURL as m } from "./useRewriteURL.mjs";
-export { r as IntlayerClient, t as createIntlayerClient, n as getIntlayerClient, e as installIntlayer, s as localeCookie, c as localeInStorage, l as setLocaleCookie, u as setLocaleInStorage, i as useDictionary, a as useDictionaryDynamic, o as useIntlayer, p as useLocale, d as useLocaleCookie, f as useLocaleStorage, m as useRewriteURL };
+import { IntlayerClient, createIntlayerClient, getIntlayerClient, installIntlayer } from "./installIntlayer.mjs";
+import { useDictionary } from "./useDictionary.mjs";
+import { useDictionaryDynamic } from "./useDictionaryDynamic.mjs";
+import { useIntlayer } from "./useIntlayer.mjs";
+import { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useLocaleCookie, useLocaleStorage } from "./useLocaleStorage.mjs";
+import { useLocale } from "./useLocale.mjs";
+import { useRewriteURL } from "./useRewriteURL.mjs";
+
+export { IntlayerClient, createIntlayerClient, getIntlayerClient, installIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useDictionary, useDictionaryDynamic, useIntlayer, useLocale, useLocaleCookie, useLocaleStorage, useRewriteURL };

package/dist/esm/client/installIntlayer.mjs

@@ -1,2 +1,93 @@
-import { i as e, n as t, r as n, t as r } from "../../installIntlayer-C99qMzFH.mjs";
-export { r as IntlayerClient, t as createIntlayerClient, n as getIntlayerClient, e as installIntlayer };
+import { useEditor } from "../editor/useEditor.mjs";
+import { internationalization } from "@intlayer/config/built";
+import { setIntlayerIdentifier } from "@intlayer/config/client";
+
+//#region src/client/installIntlayer.ts
+var IntlayerClient = class {
+	_locale;
+	_listeners = /* @__PURE__ */ new Set();
+	isCookieEnabled;
+	constructor(locale, isCookieEnabled = true) {
+		const { defaultLocale } = internationalization ?? {};
+		setIntlayerIdentifier();
+		this._locale = locale ?? defaultLocale;
+		this.isCookieEnabled = isCookieEnabled;
+	}
+	get locale() {
+		return this._locale;
+	}
+	setLocale(newLocale) {
+		this._locale = newLocale;
+		for (const listener of this._listeners) listener(newLocale);
+	}
+	subscribe(listener) {
+		this._listeners.add(listener);
+		return () => {
+			this._listeners.delete(listener);
+		};
+	}
+	/**
+	* Fire all listeners with the current locale without changing it.
+	* Used to trigger re-renders after async data loads.
+	*/
+	notify() {
+		for (const listener of this._listeners) listener(this._locale);
+	}
+};
+/**
+* Singleton instance
+*/
+let instance = null;
+/**
+* Create and return a single IntlayerClient instance.
+*/
+const createIntlayerClient = (locale, isCookieEnabled = true) => {
+	if (instance) return instance;
+	instance = new IntlayerClient(locale, isCookieEnabled);
+	return instance;
+};
+/**
+* Get the current IntlayerClient instance, creating one with defaults if needed.
+*/
+const getIntlayerClient = () => {
+	if (!instance) instance = new IntlayerClient();
+	return instance;
+};
+/**
+* Install Intlayer into your vanilla JS application.
+*
+* Call this once at application startup, before any Intlayer APIs are used.
+*
+* When called with a `config` argument, `window.INTLAYER_CONFIG` is set so
+* that `@intlayer/config/built` resolves the correct values in the browser
+* without requiring module aliasing in the bundler configuration.
+*
+* @param locale - Initial locale (defaults to config defaultLocale).
+* @param isCookieEnabled - Whether to persist locale in cookies/localStorage.
+* @param config - Optional Intlayer configuration. When provided, sets
+*   `window.INTLAYER_CONFIG` with the browser-safe subset of the config so
+*   the application works without a Vite/webpack plugin alias.
+* @returns The IntlayerClient singleton.
+*
+* @example
+* ```ts
+* import { installIntlayer } from 'vanilla-intlayer';
+*
+* // With explicit config (no build plugin alias needed):
+* installIntlayer('en', true, {
+*   internationalization: { locales: ['en', 'fr'], defaultLocale: 'en' },
+* });
+*
+* // With build plugin (alias handles config automatically):
+* installIntlayer('en');
+* ```
+*/
+const installIntlayer = ({ locale, isCookieEnabled } = {}) => {
+	const client = createIntlayerClient(locale, isCookieEnabled);
+	useEditor();
+	return client;
+};
+
+//#endregion
+export { IntlayerClient, createIntlayerClient, getIntlayerClient, installIntlayer };
+//# sourceMappingURL=installIntlayer.mjs.map

package/dist/esm/client/installIntlayer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"installIntlayer.mjs","names":[],"sources":["../../../src/client/installIntlayer.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { setIntlayerIdentifier } from '@intlayer/config/client';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { useEditor } from '../editor/useEditor';\n\ntype LocaleListener = (locale: LocalesValues) => void;\n\nexport class IntlayerClient {\n  private _locale: LocalesValues;\n  private _listeners: Set<LocaleListener> = new Set();\n  isCookieEnabled: boolean;\n\n  constructor(locale?: LocalesValues, isCookieEnabled = true) {\n    const { defaultLocale } = internationalization ?? {};\n\n    setIntlayerIdentifier();\n\n    this._locale =\n      (locale as LocalesValues) ?? (defaultLocale as LocalesValues);\n    this.isCookieEnabled = isCookieEnabled;\n  }\n\n  get locale(): LocalesValues {\n    return this._locale;\n  }\n\n  setLocale(newLocale: LocalesValues): void {\n    this._locale = newLocale;\n    for (const listener of this._listeners) {\n      listener(newLocale);\n    }\n  }\n\n  subscribe(listener: LocaleListener): () => void {\n    this._listeners.add(listener);\n    return () => {\n      this._listeners.delete(listener);\n    };\n  }\n\n  /**\n   * Fire all listeners with the current locale without changing it.\n   * Used to trigger re-renders after async data loads.\n   */\n  notify(): void {\n    for (const listener of this._listeners) {\n      listener(this._locale);\n    }\n  }\n}\n\n/**\n * Singleton instance\n */\nlet instance: IntlayerClient | null = null;\n\n/**\n * Create and return a single IntlayerClient instance.\n */\nexport const createIntlayerClient = (\n  locale?: LocalesValues,\n  isCookieEnabled = true\n): IntlayerClient => {\n  if (instance) return instance;\n\n  instance = new IntlayerClient(locale, isCookieEnabled);\n  return instance;\n};\n\n/**\n * Get the current IntlayerClient instance, creating one with defaults if needed.\n */\nexport const getIntlayerClient = (): IntlayerClient => {\n  if (!instance) {\n    instance = new IntlayerClient();\n  }\n  return instance;\n};\n\n/**\n * Install Intlayer into your vanilla JS application.\n *\n * Call this once at application startup, before any Intlayer APIs are used.\n *\n * When called with a `config` argument, `window.INTLAYER_CONFIG` is set so\n * that `@intlayer/config/built` resolves the correct values in the browser\n * without requiring module aliasing in the bundler configuration.\n *\n * @param locale - Initial locale (defaults to config defaultLocale).\n * @param isCookieEnabled - Whether to persist locale in cookies/localStorage.\n * @param config - Optional Intlayer configuration. When provided, sets\n *   `window.INTLAYER_CONFIG` with the browser-safe subset of the config so\n *   the application works without a Vite/webpack plugin alias.\n * @returns The IntlayerClient singleton.\n *\n * @example\n * ```ts\n * import { installIntlayer } from 'vanilla-intlayer';\n *\n * // With explicit config (no build plugin alias needed):\n * installIntlayer('en', true, {\n *   internationalization: { locales: ['en', 'fr'], defaultLocale: 'en' },\n * });\n *\n * // With build plugin (alias handles config automatically):\n * installIntlayer('en');\n * ```\n */\nexport const installIntlayer = ({\n  locale,\n  isCookieEnabled,\n}: {\n  locale?: LocalesValues;\n  isCookieEnabled?: boolean;\n} = {}): IntlayerClient => {\n  const client = createIntlayerClient(locale, isCookieEnabled);\n\n  useEditor();\n\n  return client;\n};\n"],"mappings":";;;;;AAOA,IAAa,iBAAb,MAA4B;CAC1B,AAAQ;CACR,AAAQ,6BAAkC,IAAI,KAAK;CACnD;CAEA,YAAY,QAAwB,kBAAkB,MAAM;EAC1D,MAAM,EAAE,kBAAkB,wBAAwB,EAAE;AAEpD,yBAAuB;AAEvB,OAAK,UACF,UAA6B;AAChC,OAAK,kBAAkB;;CAGzB,IAAI,SAAwB;AAC1B,SAAO,KAAK;;CAGd,UAAU,WAAgC;AACxC,OAAK,UAAU;AACf,OAAK,MAAM,YAAY,KAAK,WAC1B,UAAS,UAAU;;CAIvB,UAAU,UAAsC;AAC9C,OAAK,WAAW,IAAI,SAAS;AAC7B,eAAa;AACX,QAAK,WAAW,OAAO,SAAS;;;;;;;CAQpC,SAAe;AACb,OAAK,MAAM,YAAY,KAAK,WAC1B,UAAS,KAAK,QAAQ;;;;;;AAQ5B,IAAI,WAAkC;;;;AAKtC,MAAa,wBACX,QACA,kBAAkB,SACC;AACnB,KAAI,SAAU,QAAO;AAErB,YAAW,IAAI,eAAe,QAAQ,gBAAgB;AACtD,QAAO;;;;;AAMT,MAAa,0BAA0C;AACrD,KAAI,CAAC,SACH,YAAW,IAAI,gBAAgB;AAEjC,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCT,MAAa,mBAAmB,EAC9B,QACA,oBAIE,EAAE,KAAqB;CACzB,MAAM,SAAS,qBAAqB,QAAQ,gBAAgB;AAE5D,YAAW;AAEX,QAAO"}

package/dist/esm/client/useDictionary.mjs

@@ -1,11 +1,58 @@
-import { getDictionary as e } from "../getDictionary.mjs";
-import { r as t } from "../../installIntlayer-C99qMzFH.mjs";
+import { getDictionary } from "../getDictionary.mjs";
+import { getIntlayerClient } from "./installIntlayer.mjs";
+
 //#region src/client/useDictionary.ts
-var n = (n, r) => {
-	let i = t(), a = e(n, r ?? i.locale);
-	return a.onChange = (t) => (i.subscribe((i) => {
-		t(e(n, r ?? i));
-	}), a), a;
+/**
+* Get the translated content for a raw dictionary object and optionally
+* subscribe to locale changes via the chainable `.onChange()` method —
+* mirroring the API of `react-intlayer`.
+*
+* Unlike `useIntlayer` (which takes a registered key), this function accepts a
+* dictionary object directly — useful for dictionaries loaded asynchronously
+* or defined inline.
+*
+* The function returns the current content **directly** (same shape as
+* `getDictionary(dict)`), plus the `.onChange()` helper:
+*
+* ```ts
+* // React
+* const content = useDictionary(myDict);
+*
+* // Vanilla — identical surface API, opt-in reactivity via .onChange()
+* const content = useDictionary(myDict);
+* const content = useDictionary(myDict).onChange((c) => render(c));
+* ```
+*
+* @param dictionary - The raw dictionary object.
+* @param locale     - Optional locale override.
+* @returns The current translated content with an `.onChange()` method.
+*
+* @example
+* ```ts
+* import myDict from './myDictionary.content';
+* import { installIntlayer, useDictionary } from 'vanilla-intlayer';
+*
+* installIntlayer();
+*
+* const content = useDictionary(myDict).onChange((c) => {
+*   document.querySelector('p').textContent = String(c.greeting);
+* });
+*
+* document.querySelector('p').textContent = String(content.greeting);
+* ```
+*/
+const useDictionary = (dictionary, locale) => {
+	const client = getIntlayerClient();
+	const content = getDictionary(dictionary, locale ?? client.locale);
+	content.onChange = (callback) => {
+		client.subscribe((newLocale) => {
+			callback(getDictionary(dictionary, locale ?? newLocale));
+		});
+		return content;
+	};
+	return content;
 };
+
 //#endregion
-export { n as useDictionary };
+export { useDictionary };
+//# sourceMappingURL=useDictionary.mjs.map

package/dist/esm/client/useDictionary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.mjs","names":[],"sources":["../../../src/client/useDictionary.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport type { DeepTransformContent } from '../plugins';\nimport { getIntlayerClient } from './installIntlayer';\n\nexport type WithOnChange<T> = T & {\n  /**\n   * Subscribe to locale changes. The callback receives the fresh content\n   * whenever the active locale changes. Returns the content object itself\n   * for convenient one-liner patterns:\n   *\n   * ```ts\n   * const content = useDictionary(myDict).onChange((c) => {\n   *   document.querySelector('p')!.textContent = String(c.greeting);\n   * });\n   * ```\n   */\n  onChange: (\n    callback: <T extends Dictionary, L extends LocalesValues>(\n      content: DeepTransformContent<T['content'], L>\n    ) => void\n  ) => WithOnChange<T>;\n};\n\n/**\n * Get the translated content for a raw dictionary object and optionally\n * subscribe to locale changes via the chainable `.onChange()` method —\n * mirroring the API of `react-intlayer`.\n *\n * Unlike `useIntlayer` (which takes a registered key), this function accepts a\n * dictionary object directly — useful for dictionaries loaded asynchronously\n * or defined inline.\n *\n * The function returns the current content **directly** (same shape as\n * `getDictionary(dict)`), plus the `.onChange()` helper:\n *\n * ```ts\n * // React\n * const content = useDictionary(myDict);\n *\n * // Vanilla — identical surface API, opt-in reactivity via .onChange()\n * const content = useDictionary(myDict);\n * const content = useDictionary(myDict).onChange((c) => render(c));\n * ```\n *\n * @param dictionary - The raw dictionary object.\n * @param locale     - Optional locale override.\n * @returns The current translated content with an `.onChange()` method.\n *\n * @example\n * ```ts\n * import myDict from './myDictionary.content';\n * import { installIntlayer, useDictionary } from 'vanilla-intlayer';\n *\n * installIntlayer();\n *\n * const content = useDictionary(myDict).onChange((c) => {\n *   document.querySelector('p').textContent = String(c.greeting);\n * });\n *\n * document.querySelector('p').textContent = String(content.greeting);\n * ```\n */\nexport const useDictionary = <\n  T extends Dictionary,\n  L extends LocalesValues = DeclaredLocales,\n>(\n  dictionary: T,\n  locale?: L\n): WithOnChange<DeepTransformContent<T['content'], L>> => {\n  const client = getIntlayerClient();\n  const content = getDictionary(\n    dictionary,\n    (locale ?? client.locale) as L\n  ) as WithOnChange<DeepTransformContent<T['content'], L>>;\n\n  content.onChange = (\n    callback: (content: DeepTransformContent<T['content'], L>) => void\n  ) => {\n    client.subscribe((newLocale) => {\n      callback(getDictionary(dictionary, (locale ?? newLocale) as L));\n    });\n    return content;\n  };\n\n  return content;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,MAAa,iBAIX,YACA,WACwD;CACxD,MAAM,SAAS,mBAAmB;CAClC,MAAM,UAAU,cACd,YACC,UAAU,OAAO,OACnB;AAED,SAAQ,YACN,aACG;AACH,SAAO,WAAW,cAAc;AAC9B,YAAS,cAAc,YAAa,UAAU,UAAgB,CAAC;IAC/D;AACF,SAAO;;AAGT,QAAO"}

package/dist/esm/client/useDictionaryDynamic.mjs

@@ -1,37 +1,91 @@
-import { getDictionary as e } from "../getDictionary.mjs";
-import { r as t } from "../../installIntlayer-C99qMzFH.mjs";
-import { internationalization as n } from "@intlayer/config/built";
+import { getDictionary } from "../getDictionary.mjs";
+import { getIntlayerClient } from "./installIntlayer.mjs";
+import { internationalization } from "@intlayer/config/built";
+
 //#region src/client/useDictionaryDynamic.ts
-var r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = (e, t) => {
-	if (r.has(e)) return Promise.resolve();
-	if (i.has(e)) return i.get(e);
-	let n = t().then((t) => {
-		r.set(e, t), i.delete(e);
+/** Simple in-memory cache shared across all calls in the same page. */
+const cache = /* @__PURE__ */ new Map();
+/** Tracks in-flight loads to avoid duplicate fetches. */
+const inflight = /* @__PURE__ */ new Map();
+const loadDictionary = (cacheKey, loader) => {
+	if (cache.has(cacheKey)) return Promise.resolve();
+	if (inflight.has(cacheKey)) return inflight.get(cacheKey);
+	const promise = loader().then((dictionary) => {
+		cache.set(cacheKey, dictionary);
+		inflight.delete(cacheKey);
 	});
-	return i.set(e, n), n;
-}, o = (i, o, s) => {
-	let c = t(), l = s ?? c.locale ?? n.defaultLocale, u = `${String(o)}.${l}`, d = i[l], f = r.get(u);
-	if (f) {
-		let t = e(f, l);
-		return t.onChange = (n) => (c.subscribe((t) => {
-			let s = `${String(o)}.${t}`, c = i[t];
-			c && a(s, c).then(() => {
-				let i = r.get(s);
-				i && n(e(i, t));
+	inflight.set(cacheKey, promise);
+	return promise;
+};
+/**
+* Dynamically load and transform a locale-keyed dictionary.
+*
+* Works like `useIntlayer` / `useDictionary` but accepts a locale-keyed map
+* of lazy loaders instead of a pre-imported dictionary. Call it inside your
+* render function — the first call triggers a background fetch and returns
+* placeholder values; when the load completes the client notifies all
+* subscribers (including your render loop) so the render runs again with real
+* content. Subsequent calls for the same locale return immediately from cache.
+*
+* Locale switches follow the same two-phase pattern: placeholder on first
+* render, real content after the locale bundle loads.
+*
+* @param dictionaryLoaders - Locale-keyed map of `() => Promise<Dictionary>`.
+* @param key               - Dictionary key (used for cache namespacing).
+* @param locale            - Optional locale override.
+*
+* @example
+* ```ts
+* import dynDic from '../.intlayer/dynamic_dictionary/app.mjs';
+*
+* const render = () => {
+*   const content = useDictionaryDynamic(dynDic, 'app');
+*   document.querySelector('h1')!.textContent = String(content.title);
+* };
+*
+* render();
+* getIntlayerClient().subscribe(() => render());
+* ```
+*/
+const useDictionaryDynamic = (dictionaryLoaders, key, locale) => {
+	const client = getIntlayerClient();
+	const currentLocale = locale ?? client.locale ?? internationalization.defaultLocale;
+	const cacheKey = `${String(key)}.${currentLocale}`;
+	const loader = dictionaryLoaders[currentLocale];
+	const cached = cache.get(cacheKey);
+	if (cached) {
+		const content = getDictionary(cached, currentLocale);
+		content.onChange = (callback) => {
+			client.subscribe((newLocale) => {
+				const newKey = `${String(key)}.${newLocale}`;
+				const newLoader = dictionaryLoaders[newLocale];
+				if (!newLoader) return;
+				loadDictionary(newKey, newLoader).then(() => {
+					const dict = cache.get(newKey);
+					if (dict) callback(getDictionary(dict, newLocale));
+				});
 			});
-		}), t), t;
+			return content;
+		};
+		return content;
 	}
-	d && a(u, d).then(() => {
-		c.notify();
+	if (loader) loadDictionary(cacheKey, loader).then(() => {
+		client.notify();
 	});
-	let p = new Proxy(() => {}, {
-		get: (e, t) => {
-			if (t === Symbol.toPrimitive || t === "toString" || t === "valueOf") return () => "";
-			if (t !== "then") return t === "onChange" ? (e) => p : p;
+	const recursiveProxy = new Proxy(() => {}, {
+		get: (_t, prop) => {
+			if (prop === Symbol.toPrimitive) return () => "";
+			if (prop === "toString") return () => "";
+			if (prop === "valueOf") return () => "";
+			if (prop === "then") return void 0;
+			if (prop === "onChange") return (_cb) => recursiveProxy;
+			return recursiveProxy;
 		},
-		apply: () => p
+		apply: () => recursiveProxy
 	});
-	return p;
+	return recursiveProxy;
 };
+
 //#endregion
-export { o as useDictionaryDynamic };
+export { useDictionaryDynamic };
+//# sourceMappingURL=useDictionaryDynamic.mjs.map

package/dist/esm/client/useDictionaryDynamic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionaryDynamic.mjs","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport type { DeepTransformContent } from '../plugins';\nimport { getIntlayerClient } from './installIntlayer';\nimport type { WithOnChange } from './useDictionary';\n\n/** Simple in-memory cache shared across all calls in the same page. */\nconst cache = new Map<string, Dictionary>();\n\n/** Tracks in-flight loads to avoid duplicate fetches. */\nconst inflight = new Map<string, Promise<void>>();\n\nconst loadDictionary = <T extends Dictionary>(\n  cacheKey: string,\n  loader: () => Promise<T>\n): Promise<void> => {\n  if (cache.has(cacheKey)) return Promise.resolve();\n  if (inflight.has(cacheKey)) return inflight.get(cacheKey)!;\n\n  const promise = loader().then((dictionary) => {\n    cache.set(cacheKey, dictionary);\n    inflight.delete(cacheKey);\n  });\n\n  inflight.set(cacheKey, promise);\n  return promise;\n};\n\n/**\n * Dynamically load and transform a locale-keyed dictionary.\n *\n * Works like `useIntlayer` / `useDictionary` but accepts a locale-keyed map\n * of lazy loaders instead of a pre-imported dictionary. Call it inside your\n * render function — the first call triggers a background fetch and returns\n * placeholder values; when the load completes the client notifies all\n * subscribers (including your render loop) so the render runs again with real\n * content. Subsequent calls for the same locale return immediately from cache.\n *\n * Locale switches follow the same two-phase pattern: placeholder on first\n * render, real content after the locale bundle loads.\n *\n * @param dictionaryLoaders - Locale-keyed map of `() => Promise<Dictionary>`.\n * @param key               - Dictionary key (used for cache namespacing).\n * @param locale            - Optional locale override.\n *\n * @example\n * ```ts\n * import dynDic from '../.intlayer/dynamic_dictionary/app.mjs';\n *\n * const render = () => {\n *   const content = useDictionaryDynamic(dynDic, 'app');\n *   document.querySelector('h1')!.textContent = String(content.title);\n * };\n *\n * render();\n * getIntlayerClient().subscribe(() => render());\n * ```\n */\nexport const useDictionaryDynamic = <\n  T extends Dictionary,\n  K extends DictionaryKeys,\n  L extends LocalesValues = LocalesValues,\n>(\n  dictionaryLoaders: StrictModeLocaleMap<() => Promise<T>>,\n  key: K,\n  locale?: L\n): WithOnChange<DeepTransformContent<T['content'], L>> => {\n  const client = getIntlayerClient();\n  const currentLocale = (locale ??\n    client.locale ??\n    internationalization.defaultLocale) as L;\n\n  const cacheKey = `${String(key)}.${currentLocale}`;\n  const loader = (dictionaryLoaders as Record<string, () => Promise<T>>)[\n    currentLocale\n  ];\n\n  // --- Cache hit: return real content synchronously ---\n  const cached = cache.get(cacheKey);\n  if (cached) {\n    const content = getDictionary(cached as T, currentLocale) as WithOnChange<\n      DeepTransformContent<T['content'], L>\n    >;\n\n    content.onChange = (\n      callback: (content: DeepTransformContent<T['content'], L>) => void\n    ) => {\n      // Re-fire whenever content reloads (locale change → new cache entry).\n      client.subscribe((newLocale) => {\n        const newKey = `${String(key)}.${newLocale}`;\n        const newLoader = (\n          dictionaryLoaders as Record<string, () => Promise<T>>\n        )[newLocale];\n\n        if (!newLoader) return;\n\n        loadDictionary(newKey, newLoader).then(() => {\n          const dict = cache.get(newKey);\n          if (dict) {\n            callback(\n              getDictionary(dict as T, newLocale as L) as DeepTransformContent<\n                T['content'],\n                L\n              >\n            );\n          }\n        });\n      });\n\n      return content;\n    };\n\n    return content;\n  }\n\n  // --- Cache miss: kick off background load, then notify to re-render ---\n  if (loader) {\n    loadDictionary(cacheKey, loader).then(() => {\n      client.notify();\n    });\n  }\n\n  // Placeholder proxy — safe for any property access while loading.\n  const recursiveProxy: any = new Proxy(() => {}, {\n    get: (_t, prop) => {\n      if (prop === Symbol.toPrimitive) return () => '';\n      if (prop === 'toString') return () => '';\n      if (prop === 'valueOf') return () => '';\n      if (prop === 'then') return undefined; // not a Promise\n      if (prop === 'onChange') return (_cb: any) => recursiveProxy;\n      return recursiveProxy;\n    },\n    apply: () => recursiveProxy,\n  });\n\n  return recursiveProxy as WithOnChange<DeepTransformContent<T['content'], L>>;\n};\n"],"mappings":";;;;;;AAaA,MAAM,wBAAQ,IAAI,KAAyB;;AAG3C,MAAM,2BAAW,IAAI,KAA4B;AAEjD,MAAM,kBACJ,UACA,WACkB;AAClB,KAAI,MAAM,IAAI,SAAS,CAAE,QAAO,QAAQ,SAAS;AACjD,KAAI,SAAS,IAAI,SAAS,CAAE,QAAO,SAAS,IAAI,SAAS;CAEzD,MAAM,UAAU,QAAQ,CAAC,MAAM,eAAe;AAC5C,QAAM,IAAI,UAAU,WAAW;AAC/B,WAAS,OAAO,SAAS;GACzB;AAEF,UAAS,IAAI,UAAU,QAAQ;AAC/B,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCT,MAAa,wBAKX,mBACA,KACA,WACwD;CACxD,MAAM,SAAS,mBAAmB;CAClC,MAAM,gBAAiB,UACrB,OAAO,UACP,qBAAqB;CAEvB,MAAM,WAAW,GAAG,OAAO,IAAI,CAAC,GAAG;CACnC,MAAM,SAAU,kBACd;CAIF,MAAM,SAAS,MAAM,IAAI,SAAS;AAClC,KAAI,QAAQ;EACV,MAAM,UAAU,cAAc,QAAa,cAAc;AAIzD,UAAQ,YACN,aACG;AAEH,UAAO,WAAW,cAAc;IAC9B,MAAM,SAAS,GAAG,OAAO,IAAI,CAAC,GAAG;IACjC,MAAM,YACJ,kBACA;AAEF,QAAI,CAAC,UAAW;AAEhB,mBAAe,QAAQ,UAAU,CAAC,WAAW;KAC3C,MAAM,OAAO,MAAM,IAAI,OAAO;AAC9B,SAAI,KACF,UACE,cAAc,MAAW,UAAe,CAIzC;MAEH;KACF;AAEF,UAAO;;AAGT,SAAO;;AAIT,KAAI,OACF,gBAAe,UAAU,OAAO,CAAC,WAAW;AAC1C,SAAO,QAAQ;GACf;CAIJ,MAAM,iBAAsB,IAAI,YAAY,IAAI;EAC9C,MAAM,IAAI,SAAS;AACjB,OAAI,SAAS,OAAO,YAAa,cAAa;AAC9C,OAAI,SAAS,WAAY,cAAa;AACtC,OAAI,SAAS,UAAW,cAAa;AACrC,OAAI,SAAS,OAAQ,QAAO;AAC5B,OAAI,SAAS,WAAY,SAAQ,QAAa;AAC9C,UAAO;;EAET,aAAa;EACd,CAAC;AAEF,QAAO"}

package/dist/esm/client/useIntlayer.mjs

@@ -1,11 +1,64 @@
-import { getIntlayer as e } from "../getIntlayer.mjs";
-import { r as t } from "../../installIntlayer-C99qMzFH.mjs";
+import { getIntlayer } from "../getIntlayer.mjs";
+import { getIntlayerClient } from "./installIntlayer.mjs";
+
 //#region src/client/useIntlayer.ts
-var n = (n, r) => {
-	let i = t(), a = e(n, r ?? i.locale);
-	return a.onChange = (t) => (i.subscribe((i) => {
-		t(e(n, r ?? i));
-	}), a), a;
+/**
+* Get the translated content for the given key and optionally subscribe to
+* locale changes via the chainable `.onChange()` method — mirroring the API
+* of `react-intlayer`'s `useIntlayer`.
+*
+* Unlike React (where the hook system automatically re-runs on re-render),
+* vanilla JS has no component lifecycle. The `.onChange()` callback is the
+* explicit equivalent: it is called with fresh content whenever the active
+* locale changes. Use it to patch your DOM or trigger a full re-render.
+*
+* The function returns the current content **directly** (same shape as
+* `getIntlayer(key)`), plus the `.onChange()` helper:
+*
+* ```ts
+* // React
+* const content = useIntlayer('app');
+*
+* // Vanilla — identical surface API, opt-in reactivity via .onChange()
+* const content = useIntlayer('app');
+* const content = useIntlayer('app').onChange((c) => render(c));
+* ```
+*
+* For cleanup (e.g. Vite HMR), subscribe via `getIntlayerClient().subscribe()`
+* and hold the returned unsubscribe function.
+*
+* @param key    - Dictionary key registered in your intlayer content files.
+* @param locale - Optional locale override (defaults to the current app locale).
+* @returns The current translated content with an `.onChange()` method.
+*
+* @example
+* ```ts
+* import { installIntlayer, useIntlayer } from 'vanilla-intlayer';
+*
+* installIntlayer();
+*
+* // Static read (no subscription)
+* const content = useIntlayer('homepage');
+* document.querySelector('h1').textContent = String(content.title);
+*
+* // Reactive read — onChange is called on every locale change
+* useIntlayer('homepage').onChange((c) => {
+*   document.querySelector('h1').textContent = String(c.title);
+* });
+* ```
+*/
+const useIntlayer = (key, locale) => {
+	const client = getIntlayerClient();
+	const content = getIntlayer(key, locale ?? client.locale);
+	content.onChange = (callback) => {
+		client.subscribe((newLocale) => {
+			callback(getIntlayer(key, locale ?? newLocale));
+		});
+		return content;
+	};
+	return content;
 };
+
 //#endregion
-export { n as useIntlayer };
+export { useIntlayer };
+//# sourceMappingURL=useIntlayer.mjs.map

package/dist/esm/client/useIntlayer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIntlayer.mjs","names":[],"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["import type {\n  DictionaryKeys,\n  DictionaryRegistryContent,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getIntlayer } from '../getIntlayer';\nimport type { DeepTransformContent } from '../plugins';\nimport { getIntlayerClient } from './installIntlayer';\nimport type { WithOnChange } from './useDictionary';\n\n/**\n * Get the translated content for the given key and optionally subscribe to\n * locale changes via the chainable `.onChange()` method — mirroring the API\n * of `react-intlayer`'s `useIntlayer`.\n *\n * Unlike React (where the hook system automatically re-runs on re-render),\n * vanilla JS has no component lifecycle. The `.onChange()` callback is the\n * explicit equivalent: it is called with fresh content whenever the active\n * locale changes. Use it to patch your DOM or trigger a full re-render.\n *\n * The function returns the current content **directly** (same shape as\n * `getIntlayer(key)`), plus the `.onChange()` helper:\n *\n * ```ts\n * // React\n * const content = useIntlayer('app');\n *\n * // Vanilla — identical surface API, opt-in reactivity via .onChange()\n * const content = useIntlayer('app');\n * const content = useIntlayer('app').onChange((c) => render(c));\n * ```\n *\n * For cleanup (e.g. Vite HMR), subscribe via `getIntlayerClient().subscribe()`\n * and hold the returned unsubscribe function.\n *\n * @param key    - Dictionary key registered in your intlayer content files.\n * @param locale - Optional locale override (defaults to the current app locale).\n * @returns The current translated content with an `.onChange()` method.\n *\n * @example\n * ```ts\n * import { installIntlayer, useIntlayer } from 'vanilla-intlayer';\n *\n * installIntlayer();\n *\n * // Static read (no subscription)\n * const content = useIntlayer('homepage');\n * document.querySelector('h1').textContent = String(content.title);\n *\n * // Reactive read — onChange is called on every locale change\n * useIntlayer('homepage').onChange((c) => {\n *   document.querySelector('h1').textContent = String(c.title);\n * });\n * ```\n */\nexport const useIntlayer = <T extends DictionaryKeys>(\n  key: T,\n  locale?: LocalesValues\n): WithOnChange<DeepTransformContent<DictionaryRegistryContent<T>>> => {\n  const client = getIntlayerClient();\n  const content = getIntlayer(key, locale ?? client.locale) as WithOnChange<\n    DeepTransformContent<DictionaryRegistryContent<T>>\n  >;\n\n  content.onChange = (callback) => {\n    client.subscribe((newLocale) => {\n      callback(getIntlayer(key, (locale ?? newLocale) as typeof locale));\n    });\n    return content;\n  };\n\n  return content;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,MAAa,eACX,KACA,WACqE;CACrE,MAAM,SAAS,mBAAmB;CAClC,MAAM,UAAU,YAAY,KAAK,UAAU,OAAO,OAAO;AAIzD,SAAQ,YAAY,aAAa;AAC/B,SAAO,WAAW,cAAc;AAC9B,YAAS,YAAY,KAAM,UAAU,UAA4B,CAAC;IAClE;AACF,SAAO;;AAGT,QAAO"}

package/dist/esm/client/useLocale.mjs

@@ -1,22 +1,56 @@
-import { r as e } from "../../installIntlayer-C99qMzFH.mjs";
-import { setLocaleInStorage as t } from "./useLocaleStorage.mjs";
-import { internationalization as n } from "@intlayer/config/built";
+import { getIntlayerClient } from "./installIntlayer.mjs";
+import { setLocaleInStorage } from "./useLocaleStorage.mjs";
+import { internationalization } from "@intlayer/config/built";
+
 //#region src/client/useLocale.ts
-var r = (r = {}) => {
-	let i = e(), { defaultLocale: a, locales: o } = n ?? {};
+/**
+* Get the current locale state and locale management utilities.
+*
+* Returns a plain object with the current `locale`, `defaultLocale`,
+* `availableLocales`, a `setLocale` function, and a `subscribe` function
+* to react to locale changes.
+*
+* @param props - Optional configuration.
+* @returns Locale state and management utilities.
+*
+* @example
+* ```ts
+* import { installIntlayer, useLocale } from 'vanilla-intlayer';
+*
+* installIntlayer('en');
+*
+* const { locale, availableLocales, setLocale, subscribe } = useLocale();
+*
+* const unsubscribe = subscribe((newLocale) => {
+*   console.log('Locale changed to', newLocale);
+* });
+*
+* document.querySelector('#lang-switcher').addEventListener('change', (e) => {
+*   setLocale(e.target.value);
+* });
+* ```
+*/
+const useLocale = (props = {}) => {
+	const client = getIntlayerClient();
+	const { defaultLocale, locales: availableLocales } = internationalization ?? {};
+	const setLocale = (newLocale) => {
+		if (!(availableLocales ?? []).map(String).includes(newLocale)) {
+			console.error(`Locale "${newLocale}" is not available.`);
+			return;
+		}
+		client.setLocale(newLocale);
+		setLocaleInStorage(newLocale, props.isCookieEnabled ?? client.isCookieEnabled ?? true);
+		props.onLocaleChange?.(newLocale);
+	};
 	return {
-		locale: i.locale,
-		defaultLocale: a,
-		availableLocales: o ?? [],
-		setLocale: (e) => {
-			if (!(o ?? []).map(String).includes(e)) {
-				console.error(`Locale "${e}" is not available.`);
-				return;
-			}
-			i.setLocale(e), t(e, r.isCookieEnabled ?? i.isCookieEnabled ?? !0), r.onLocaleChange?.(e);
-		},
-		subscribe: (e) => i.subscribe(e)
+		locale: client.locale,
+		defaultLocale,
+		availableLocales: availableLocales ?? [],
+		setLocale,
+		subscribe: (callback) => client.subscribe(callback)
 	};
 };
+
 //#endregion
-export { r as useLocale };
+export { useLocale };
+//# sourceMappingURL=useLocale.mjs.map

package/dist/esm/client/useLocale.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.mjs","names":[],"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getIntlayerClient } from './installIntlayer';\nimport { setLocaleInStorage } from './useLocaleStorage';\n\ntype UseLocaleProps = {\n  isCookieEnabled?: boolean;\n  onLocaleChange?: (locale: LocalesValues) => void;\n};\n\n/**\n * Get the current locale state and locale management utilities.\n *\n * Returns a plain object with the current `locale`, `defaultLocale`,\n * `availableLocales`, a `setLocale` function, and a `subscribe` function\n * to react to locale changes.\n *\n * @param props - Optional configuration.\n * @returns Locale state and management utilities.\n *\n * @example\n * ```ts\n * import { installIntlayer, useLocale } from 'vanilla-intlayer';\n *\n * installIntlayer('en');\n *\n * const { locale, availableLocales, setLocale, subscribe } = useLocale();\n *\n * const unsubscribe = subscribe((newLocale) => {\n *   console.log('Locale changed to', newLocale);\n * });\n *\n * document.querySelector('#lang-switcher').addEventListener('change', (e) => {\n *   setLocale(e.target.value);\n * });\n * ```\n */\nexport const useLocale = (\n  props: UseLocaleProps = {}\n): {\n  locale: DeclaredLocales;\n  defaultLocale: DeclaredLocales;\n  availableLocales: DeclaredLocales[];\n  setLocale: (newLocale: LocalesValues) => void;\n  subscribe: (callback: (locale: LocalesValues) => void) => () => void;\n} => {\n  const client = getIntlayerClient();\n  const { defaultLocale, locales: availableLocales } =\n    internationalization ?? {};\n\n  const setLocale = (newLocale: LocalesValues): void => {\n    if (!(availableLocales ?? []).map(String).includes(newLocale)) {\n      console.error(`Locale \"${newLocale}\" is not available.`);\n      return;\n    }\n\n    client.setLocale(newLocale);\n\n    setLocaleInStorage(\n      newLocale,\n      props.isCookieEnabled ?? client.isCookieEnabled ?? true\n    );\n\n    props.onLocaleChange?.(newLocale);\n  };\n\n  return {\n    locale: client.locale as DeclaredLocales,\n    defaultLocale: defaultLocale as DeclaredLocales,\n    availableLocales: (availableLocales ?? []) as DeclaredLocales[],\n    setLocale,\n    subscribe: (callback) => client.subscribe(callback),\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,MAAa,aACX,QAAwB,EAAE,KAOvB;CACH,MAAM,SAAS,mBAAmB;CAClC,MAAM,EAAE,eAAe,SAAS,qBAC9B,wBAAwB,EAAE;CAE5B,MAAM,aAAa,cAAmC;AACpD,MAAI,EAAE,oBAAoB,EAAE,EAAE,IAAI,OAAO,CAAC,SAAS,UAAU,EAAE;AAC7D,WAAQ,MAAM,WAAW,UAAU,qBAAqB;AACxD;;AAGF,SAAO,UAAU,UAAU;AAE3B,qBACE,WACA,MAAM,mBAAmB,OAAO,mBAAmB,KACpD;AAED,QAAM,iBAAiB,UAAU;;AAGnC,QAAO;EACL,QAAQ,OAAO;EACA;EACf,kBAAmB,oBAAoB,EAAE;EACzC;EACA,YAAY,aAAa,OAAO,UAAU,SAAS;EACpD"}

package/dist/esm/client/useLocaleStorage.mjs

@@ -1,18 +1,44 @@
-import { localeStorageOptions as e } from "@intlayer/core/localization";
-import { LocaleStorageClient as t, getLocaleFromStorageClient as n, setLocaleInStorageClient as r } from "@intlayer/core/utils";
+import { localeStorageOptions } from "@intlayer/core/localization";
+import { LocaleStorageClient, getLocaleFromStorageClient, setLocaleInStorageClient } from "@intlayer/core/utils";
+
 //#region src/client/useLocaleStorage.ts
-var i = n(e), a = i, o = (t, n) => r(t, {
-	...e,
-	isCookieEnabled: n
-}), s = o, c = (n) => {
-	let r = t({
-		...e,
-		isCookieEnabled: n
+/**
+* Get the current locale from storage (cookie or localStorage).
+*/
+const localeInStorage = getLocaleFromStorageClient(localeStorageOptions);
+/**
+* @deprecated Use localeInStorage instead.
+*/
+const localeCookie = localeInStorage;
+/**
+* Persist the locale to storage (cookie and/or localStorage).
+*/
+const setLocaleInStorage = (locale, isCookieEnabled) => setLocaleInStorageClient(locale, {
+	...localeStorageOptions,
+	isCookieEnabled
+});
+/**
+* @deprecated Use setLocaleInStorage instead.
+*/
+const setLocaleCookie = setLocaleInStorage;
+/**
+* Returns the current locale from storage and a setter.
+*/
+const useLocaleStorage = (isCookieEnabled) => {
+	const storage = LocaleStorageClient({
+		...localeStorageOptions,
+		isCookieEnabled
 	});
 	return {
-		localeStorage: r.getLocale(),
-		setLocaleStorage: r.setLocale
+		localeStorage: storage.getLocale(),
+		setLocaleStorage: storage.setLocale
 	};
-}, l = c;
+};
+/**
+* @deprecated Use useLocaleStorage instead.
+*/
+const useLocaleCookie = useLocaleStorage;
+
 //#endregion
-export { a as localeCookie, i as localeInStorage, s as setLocaleCookie, o as setLocaleInStorage, l as useLocaleCookie, c as useLocaleStorage };
+export { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useLocaleCookie, useLocaleStorage };
+//# sourceMappingURL=useLocaleStorage.mjs.map

package/dist/esm/client/useLocaleStorage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocaleStorage.mjs","names":["setLocaleInStorageCore"],"sources":["../../../src/client/useLocaleStorage.ts"],"sourcesContent":["import { localeStorageOptions } from '@intlayer/core/localization';\nimport {\n  getLocaleFromStorageClient,\n  LocaleStorageClient,\n  setLocaleInStorageClient as setLocaleInStorageCore,\n} from '@intlayer/core/utils';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\n/**\n * Get the current locale from storage (cookie or localStorage).\n */\nexport const localeInStorage = getLocaleFromStorageClient(localeStorageOptions);\n\n/**\n * @deprecated Use localeInStorage instead.\n */\nexport const localeCookie = localeInStorage;\n\n/**\n * Persist the locale to storage (cookie and/or localStorage).\n */\nexport const setLocaleInStorage = (\n  locale: LocalesValues,\n  isCookieEnabled: boolean\n) =>\n  setLocaleInStorageCore(locale, {\n    ...localeStorageOptions,\n    isCookieEnabled,\n  });\n\n/**\n * @deprecated Use setLocaleInStorage instead.\n */\nexport const setLocaleCookie = setLocaleInStorage;\n\n/**\n * Returns the current locale from storage and a setter.\n */\nexport const useLocaleStorage = (isCookieEnabled?: boolean) => {\n  const storage = LocaleStorageClient({\n    ...localeStorageOptions,\n    isCookieEnabled,\n  });\n\n  return {\n    localeStorage: storage.getLocale(),\n    setLocaleStorage: storage.setLocale,\n  };\n};\n\n/**\n * @deprecated Use useLocaleStorage instead.\n */\nexport const useLocaleCookie = useLocaleStorage;\n"],"mappings":";;;;;;;AAWA,MAAa,kBAAkB,2BAA2B,qBAAqB;;;;AAK/E,MAAa,eAAe;;;;AAK5B,MAAa,sBACX,QACA,oBAEAA,yBAAuB,QAAQ;CAC7B,GAAG;CACH;CACD,CAAC;;;;AAKJ,MAAa,kBAAkB;;;;AAK/B,MAAa,oBAAoB,oBAA8B;CAC7D,MAAM,UAAU,oBAAoB;EAClC,GAAG;EACH;EACD,CAAC;AAEF,QAAO;EACL,eAAe,QAAQ,WAAW;EAClC,kBAAkB,QAAQ;EAC3B;;;;;AAMH,MAAa,kBAAkB"}

package/dist/esm/client/useRewriteURL.mjs

@@ -1,16 +1,44 @@
-import { r as e } from "../../installIntlayer-C99qMzFH.mjs";
-import { routing as t } from "@intlayer/config/built";
-import { getRewritePath as n } from "@intlayer/core/localization";
+import { getIntlayerClient } from "./installIntlayer.mjs";
+import { routing } from "@intlayer/config/built";
+import { getRewritePath } from "@intlayer/core/localization";
+
 //#region src/client/useRewriteURL.ts
-var r = (e) => {
-	if (typeof window > "u" || !t?.rewrite) return;
-	let r = window.location.pathname, i = n(r, e, t?.rewrite);
-	i && i !== r && window.history.replaceState(window.history.state, "", i + window.location.search + window.location.hash);
-}, i = () => {
-	let t = e();
-	return r(t.locale), t.subscribe((e) => {
-		r(e);
+const rewrite = (locale) => {
+	if (typeof window === "undefined" || !routing?.rewrite) return;
+	const pathname = window.location.pathname;
+	const targetPath = getRewritePath(pathname, locale, routing?.rewrite);
+	if (targetPath && targetPath !== pathname) window.history.replaceState(window.history.state, "", targetPath + window.location.search + window.location.hash);
+};
+/**
+* Keep the browser URL in sync with the current locale.
+*
+* Rewrites the current URL immediately and subscribes to future locale changes.
+* Returns an `unsubscribe` function to stop listening.
+*
+* Uses `window.history.replaceState` — no full-page navigation.
+*
+* @returns A cleanup function that removes the locale change listener.
+*
+* @example
+* ```ts
+* import { installIntlayer, useRewriteURL } from 'vanilla-intlayer';
+*
+* installIntlayer('en');
+*
+* const unsubscribe = useRewriteURL();
+*
+* // Later, if you want to stop URL rewriting:
+* unsubscribe();
+* ```
+*/
+const useRewriteURL = () => {
+	const client = getIntlayerClient();
+	rewrite(client.locale);
+	return client.subscribe((newLocale) => {
+		rewrite(newLocale);
 	});
 };
+
 //#endregion
-export { i as useRewriteURL };
+export { useRewriteURL };
+//# sourceMappingURL=useRewriteURL.mjs.map

package/dist/esm/client/useRewriteURL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRewriteURL.mjs","names":[],"sources":["../../../src/client/useRewriteURL.ts"],"sourcesContent":["import { routing } from '@intlayer/config/built';\nimport { getRewritePath } from '@intlayer/core/localization';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport { getIntlayerClient } from './installIntlayer';\n\nconst rewrite = (locale: string): void => {\n  if (typeof window === 'undefined' || !routing?.rewrite) return;\n\n  const pathname = window.location.pathname;\n  const targetPath = getRewritePath(\n    pathname,\n    locale as Locale,\n    routing?.rewrite\n  );\n\n  if (targetPath && targetPath !== pathname) {\n    window.history.replaceState(\n      window.history.state,\n      '',\n      targetPath + window.location.search + window.location.hash\n    );\n  }\n};\n\n/**\n * Keep the browser URL in sync with the current locale.\n *\n * Rewrites the current URL immediately and subscribes to future locale changes.\n * Returns an `unsubscribe` function to stop listening.\n *\n * Uses `window.history.replaceState` — no full-page navigation.\n *\n * @returns A cleanup function that removes the locale change listener.\n *\n * @example\n * ```ts\n * import { installIntlayer, useRewriteURL } from 'vanilla-intlayer';\n *\n * installIntlayer('en');\n *\n * const unsubscribe = useRewriteURL();\n *\n * // Later, if you want to stop URL rewriting:\n * unsubscribe();\n * ```\n */\nexport const useRewriteURL = (): (() => void) => {\n  const client = getIntlayerClient();\n\n  // Rewrite immediately for the current locale\n  rewrite(client.locale);\n\n  return client.subscribe((newLocale) => {\n    rewrite(newLocale);\n  });\n};\n"],"mappings":";;;;;AAKA,MAAM,WAAW,WAAyB;AACxC,KAAI,OAAO,WAAW,eAAe,CAAC,SAAS,QAAS;CAExD,MAAM,WAAW,OAAO,SAAS;CACjC,MAAM,aAAa,eACjB,UACA,QACA,SAAS,QACV;AAED,KAAI,cAAc,eAAe,SAC/B,QAAO,QAAQ,aACb,OAAO,QAAQ,OACf,IACA,aAAa,OAAO,SAAS,SAAS,OAAO,SAAS,KACvD;;;;;;;;;;;;;;;;;;;;;;;;AA0BL,MAAa,sBAAoC;CAC/C,MAAM,SAAS,mBAAmB;AAGlC,SAAQ,OAAO,OAAO;AAEtB,QAAO,OAAO,WAAW,cAAc;AACrC,UAAQ,UAAU;GAClB"}