vanilla-intlayer 8.8.0 → 8.9.0

package/dist/cjs/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,29 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/cjs/client/index.cjs

@@ -1 +1,24 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../installIntlayer-_1cC62gP.js`),t=require(`./useDictionary.cjs`),n=require(`./useDictionaryDynamic.cjs`),r=require(`./useIntlayer.cjs`),i=require(`./useLocaleStorage.cjs`),a=require(`./useLocale.cjs`),o=require(`./useRewriteURL.cjs`);exports.IntlayerClient=e.t,exports.createIntlayerClient=e.n,exports.getIntlayerClient=e.r,exports.installIntlayer=e.i,exports.localeCookie=i.localeCookie,exports.localeInStorage=i.localeInStorage,exports.setLocaleCookie=i.setLocaleCookie,exports.setLocaleInStorage=i.setLocaleInStorage,exports.useDictionary=t.useDictionary,exports.useDictionaryDynamic=n.useDictionaryDynamic,exports.useIntlayer=r.useIntlayer,exports.useLocale=a.useLocale,exports.useLocaleCookie=i.useLocaleCookie,exports.useLocaleStorage=i.useLocaleStorage,exports.useRewriteURL=o.useRewriteURL;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_client_installIntlayer = require('./installIntlayer.cjs');
+const require_client_useDictionary = require('./useDictionary.cjs');
+const require_client_useDictionaryDynamic = require('./useDictionaryDynamic.cjs');
+const require_client_useIntlayer = require('./useIntlayer.cjs');
+const require_client_useLocaleStorage = require('./useLocaleStorage.cjs');
+const require_client_useLocale = require('./useLocale.cjs');
+const require_client_useRewriteURL = require('./useRewriteURL.cjs');
+
+exports.IntlayerClient = require_client_installIntlayer.IntlayerClient;
+exports.createIntlayerClient = require_client_installIntlayer.createIntlayerClient;
+exports.getIntlayerClient = require_client_installIntlayer.getIntlayerClient;
+exports.installIntlayer = require_client_installIntlayer.installIntlayer;
+exports.localeCookie = require_client_useLocaleStorage.localeCookie;
+exports.localeInStorage = require_client_useLocaleStorage.localeInStorage;
+exports.setLocaleCookie = require_client_useLocaleStorage.setLocaleCookie;
+exports.setLocaleInStorage = require_client_useLocaleStorage.setLocaleInStorage;
+exports.useDictionary = require_client_useDictionary.useDictionary;
+exports.useDictionaryDynamic = require_client_useDictionaryDynamic.useDictionaryDynamic;
+exports.useIntlayer = require_client_useIntlayer.useIntlayer;
+exports.useLocale = require_client_useLocale.useLocale;
+exports.useLocaleCookie = require_client_useLocaleStorage.useLocaleCookie;
+exports.useLocaleStorage = require_client_useLocaleStorage.useLocaleStorage;
+exports.useRewriteURL = require_client_useRewriteURL.useRewriteURL;

package/dist/cjs/client/installIntlayer.cjs

@@ -1 +1,98 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../installIntlayer-_1cC62gP.js`);exports.IntlayerClient=e.t,exports.createIntlayerClient=e.n,exports.getIntlayerClient=e.r,exports.installIntlayer=e.i;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_editor_useEditor = require('../editor/useEditor.cjs');
+let _intlayer_config_built = require("@intlayer/config/built");
+let _intlayer_config_client = require("@intlayer/config/client");
+
+//#region src/client/installIntlayer.ts
+var IntlayerClient = class {
+	_locale;
+	_listeners = /* @__PURE__ */ new Set();
+	isCookieEnabled;
+	constructor(locale, isCookieEnabled = true) {
+		const { defaultLocale } = _intlayer_config_built.internationalization ?? {};
+		(0, _intlayer_config_client.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);
+	require_editor_useEditor.useEditor();
+	return client;
+};
+
+//#endregion
+exports.IntlayerClient = IntlayerClient;
+exports.createIntlayerClient = createIntlayerClient;
+exports.getIntlayerClient = getIntlayerClient;
+exports.installIntlayer = installIntlayer;
+//# sourceMappingURL=installIntlayer.cjs.map

package/dist/cjs/client/installIntlayer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"installIntlayer.cjs","names":["internationalization"],"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,kBAAkBA,+CAAwB,EAAE;AAEpD,sDAAuB;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,qCAAW;AAEX,QAAO"}

package/dist/cjs/client/useDictionary.cjs

@@ -1 +1,59 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../getDictionary.cjs`),t=require(`../../installIntlayer-_1cC62gP.js`);var n=(n,r)=>{let i=t.r(),a=e.getDictionary(n,r??i.locale);return a.onChange=t=>(i.subscribe(i=>{t(e.getDictionary(n,r??i))}),a),a};exports.useDictionary=n;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_getDictionary = require('../getDictionary.cjs');
+const require_client_installIntlayer = require('./installIntlayer.cjs');
+
+//#region src/client/useDictionary.ts
+/**
+* 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 = require_client_installIntlayer.getIntlayerClient();
+	const content = require_getDictionary.getDictionary(dictionary, locale ?? client.locale);
+	content.onChange = (callback) => {
+		client.subscribe((newLocale) => {
+			callback(require_getDictionary.getDictionary(dictionary, locale ?? newLocale));
+		});
+		return content;
+	};
+	return content;
+};
+
+//#endregion
+exports.useDictionary = useDictionary;
+//# sourceMappingURL=useDictionary.cjs.map

package/dist/cjs/client/useDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.cjs","names":["getIntlayerClient","getDictionary"],"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,SAASA,kDAAmB;CAClC,MAAM,UAAUC,oCACd,YACC,UAAU,OAAO,OACnB;AAED,SAAQ,YACN,aACG;AACH,SAAO,WAAW,cAAc;AAC9B,YAASA,oCAAc,YAAa,UAAU,UAAgB,CAAC;IAC/D;AACF,SAAO;;AAGT,QAAO"}

package/dist/cjs/client/useDictionaryDynamic.cjs

@@ -1 +1,93 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`}),require(`../../plugins-Cv8sSUPw.js`);const e=require(`../getDictionary.cjs`),t=require(`../../installIntlayer-_1cC62gP.js`);let n=require(`@intlayer/config/built`);var r=new Map,i=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)});return i.set(e,n),n},o=(i,o,s)=>{let c=t.r(),l=s??c.locale??n.internationalization.defaultLocale,u=`${String(o)}.${l}`,d=i[l],f=r.get(u);if(f){let t=e.getDictionary(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.getDictionary(i,t))})}),t),t}d&&a(u,d).then(()=>{c.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},apply:()=>p});return p};exports.useDictionaryDynamic=o;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_getDictionary = require('../getDictionary.cjs');
+const require_client_installIntlayer = require('./installIntlayer.cjs');
+let _intlayer_config_built = require("@intlayer/config/built");
+
+//#region src/client/useDictionaryDynamic.ts
+/** 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);
+	});
+	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 = require_client_installIntlayer.getIntlayerClient();
+	const currentLocale = locale ?? client.locale ?? _intlayer_config_built.internationalization.defaultLocale;
+	const cacheKey = `${String(key)}.${currentLocale}`;
+	const loader = dictionaryLoaders[currentLocale];
+	const cached = cache.get(cacheKey);
+	if (cached) {
+		const content = require_getDictionary.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(require_getDictionary.getDictionary(dict, newLocale));
+				});
+			});
+			return content;
+		};
+		return content;
+	}
+	if (loader) loadDictionary(cacheKey, loader).then(() => {
+		client.notify();
+	});
+	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: () => recursiveProxy
+	});
+	return recursiveProxy;
+};
+
+//#endregion
+exports.useDictionaryDynamic = useDictionaryDynamic;
+//# sourceMappingURL=useDictionaryDynamic.cjs.map

package/dist/cjs/client/useDictionaryDynamic.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionaryDynamic.cjs","names":["getIntlayerClient","internationalization","getDictionary"],"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,SAASA,kDAAmB;CAClC,MAAM,gBAAiB,UACrB,OAAO,UACPC,4CAAqB;CAEvB,MAAM,WAAW,GAAG,OAAO,IAAI,CAAC,GAAG;CACnC,MAAM,SAAU,kBACd;CAIF,MAAM,SAAS,MAAM,IAAI,SAAS;AAClC,KAAI,QAAQ;EACV,MAAM,UAAUC,oCAAc,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,UACEA,oCAAc,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/cjs/client/useIntlayer.cjs

@@ -1 +1,65 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../getIntlayer.cjs`),t=require(`../../installIntlayer-_1cC62gP.js`);var n=(n,r)=>{let i=t.r(),a=e.getIntlayer(n,r??i.locale);return a.onChange=t=>(i.subscribe(i=>{t(e.getIntlayer(n,r??i))}),a),a};exports.useIntlayer=n;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_getIntlayer = require('../getIntlayer.cjs');
+const require_client_installIntlayer = require('./installIntlayer.cjs');
+
+//#region src/client/useIntlayer.ts
+/**
+* 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 = require_client_installIntlayer.getIntlayerClient();
+	const content = require_getIntlayer.getIntlayer(key, locale ?? client.locale);
+	content.onChange = (callback) => {
+		client.subscribe((newLocale) => {
+			callback(require_getIntlayer.getIntlayer(key, locale ?? newLocale));
+		});
+		return content;
+	};
+	return content;
+};
+
+//#endregion
+exports.useIntlayer = useIntlayer;
+//# sourceMappingURL=useIntlayer.cjs.map

package/dist/cjs/client/useIntlayer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIntlayer.cjs","names":["getIntlayerClient","getIntlayer"],"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,SAASA,kDAAmB;CAClC,MAAM,UAAUC,gCAAY,KAAK,UAAU,OAAO,OAAO;AAIzD,SAAQ,YAAY,aAAa;AAC/B,SAAO,WAAW,cAAc;AAC9B,YAASA,gCAAY,KAAM,UAAU,UAA4B,CAAC;IAClE;AACF,SAAO;;AAGT,QAAO"}

package/dist/cjs/client/useLocale.cjs

@@ -1 +1,58 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`}),require(`../../plugins-Cv8sSUPw.js`);const e=require(`../../installIntlayer-_1cC62gP.js`),t=require(`./useLocaleStorage.cjs`);let n=require(`@intlayer/config/built`);var r=(r={})=>{let i=e.r(),{defaultLocale:a,locales:o}=n.internationalization??{};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.setLocaleInStorage(e,r.isCookieEnabled??i.isCookieEnabled??!0),r.onLocaleChange?.(e)},subscribe:e=>i.subscribe(e)}};exports.useLocale=r;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_client_installIntlayer = require('./installIntlayer.cjs');
+const require_client_useLocaleStorage = require('./useLocaleStorage.cjs');
+let _intlayer_config_built = require("@intlayer/config/built");
+
+//#region src/client/useLocale.ts
+/**
+* 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 = require_client_installIntlayer.getIntlayerClient();
+	const { defaultLocale, locales: availableLocales } = _intlayer_config_built.internationalization ?? {};
+	const setLocale = (newLocale) => {
+		if (!(availableLocales ?? []).map(String).includes(newLocale)) {
+			console.error(`Locale "${newLocale}" is not available.`);
+			return;
+		}
+		client.setLocale(newLocale);
+		require_client_useLocaleStorage.setLocaleInStorage(newLocale, props.isCookieEnabled ?? client.isCookieEnabled ?? true);
+		props.onLocaleChange?.(newLocale);
+	};
+	return {
+		locale: client.locale,
+		defaultLocale,
+		availableLocales: availableLocales ?? [],
+		setLocale,
+		subscribe: (callback) => client.subscribe(callback)
+	};
+};
+
+//#endregion
+exports.useLocale = useLocale;
+//# sourceMappingURL=useLocale.cjs.map

package/dist/cjs/client/useLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.cjs","names":["getIntlayerClient","internationalization"],"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,SAASA,kDAAmB;CAClC,MAAM,EAAE,eAAe,SAAS,qBAC9BC,+CAAwB,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,qDACE,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/cjs/client/useLocaleStorage.cjs

@@ -1 +1,51 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`}),require(`../../plugins-Cv8sSUPw.js`);let e=require(`@intlayer/core/localization`),t=require(`@intlayer/core/utils`);var n=(0,t.getLocaleFromStorageClient)(e.localeStorageOptions),r=n,i=(n,r)=>(0,t.setLocaleInStorageClient)(n,{...e.localeStorageOptions,isCookieEnabled:r}),a=i,o=n=>{let r=(0,t.LocaleStorageClient)({...e.localeStorageOptions,isCookieEnabled:n});return{localeStorage:r.getLocale(),setLocaleStorage:r.setLocale}},s=o;exports.localeCookie=r,exports.localeInStorage=n,exports.setLocaleCookie=a,exports.setLocaleInStorage=i,exports.useLocaleCookie=s,exports.useLocaleStorage=o;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let _intlayer_core_localization = require("@intlayer/core/localization");
+let _intlayer_core_utils = require("@intlayer/core/utils");
+
+//#region src/client/useLocaleStorage.ts
+/**
+* Get the current locale from storage (cookie or localStorage).
+*/
+const localeInStorage = (0, _intlayer_core_utils.getLocaleFromStorageClient)(_intlayer_core_localization.localeStorageOptions);
+/**
+* @deprecated Use localeInStorage instead.
+*/
+const localeCookie = localeInStorage;
+/**
+* Persist the locale to storage (cookie and/or localStorage).
+*/
+const setLocaleInStorage = (locale, isCookieEnabled) => (0, _intlayer_core_utils.setLocaleInStorageClient)(locale, {
+	..._intlayer_core_localization.localeStorageOptions,
+	isCookieEnabled
+});
+/**
+* @deprecated Use setLocaleInStorage instead.
+*/
+const setLocaleCookie = setLocaleInStorage;
+/**
+* Returns the current locale from storage and a setter.
+*/
+const useLocaleStorage = (isCookieEnabled) => {
+	const storage = (0, _intlayer_core_utils.LocaleStorageClient)({
+		..._intlayer_core_localization.localeStorageOptions,
+		isCookieEnabled
+	});
+	return {
+		localeStorage: storage.getLocale(),
+		setLocaleStorage: storage.setLocale
+	};
+};
+/**
+* @deprecated Use useLocaleStorage instead.
+*/
+const useLocaleCookie = useLocaleStorage;
+
+//#endregion
+exports.localeCookie = localeCookie;
+exports.localeInStorage = localeInStorage;
+exports.setLocaleCookie = setLocaleCookie;
+exports.setLocaleInStorage = setLocaleInStorage;
+exports.useLocaleCookie = useLocaleCookie;
+exports.useLocaleStorage = useLocaleStorage;
+//# sourceMappingURL=useLocaleStorage.cjs.map

package/dist/cjs/client/useLocaleStorage.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocaleStorage.cjs","names":["localeStorageOptions"],"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,uEAA6CA,iDAAqB;;;;AAK/E,MAAa,eAAe;;;;AAK5B,MAAa,sBACX,QACA,uEAEuB,QAAQ;CAC7B,GAAGA;CACH;CACD,CAAC;;;;AAKJ,MAAa,kBAAkB;;;;AAK/B,MAAa,oBAAoB,oBAA8B;CAC7D,MAAM,wDAA8B;EAClC,GAAGA;EACH;EACD,CAAC;AAEF,QAAO;EACL,eAAe,QAAQ,WAAW;EAClC,kBAAkB,QAAQ;EAC3B;;;;;AAMH,MAAa,kBAAkB"}

package/dist/cjs/client/useRewriteURL.cjs

@@ -1 +1,46 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`}),require(`../../plugins-Cv8sSUPw.js`);const e=require(`../../installIntlayer-_1cC62gP.js`);let t=require(`@intlayer/config/built`),n=require(`@intlayer/core/localization`);var r=e=>{if(typeof window>`u`||!t.routing?.rewrite)return;let r=window.location.pathname,i=(0,n.getRewritePath)(r,e,t.routing?.rewrite);i&&i!==r&&window.history.replaceState(window.history.state,``,i+window.location.search+window.location.hash)},i=()=>{let t=e.r();return r(t.locale),t.subscribe(e=>{r(e)})};exports.useRewriteURL=i;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_client_installIntlayer = require('./installIntlayer.cjs');
+let _intlayer_config_built = require("@intlayer/config/built");
+let _intlayer_core_localization = require("@intlayer/core/localization");
+
+//#region src/client/useRewriteURL.ts
+const rewrite = (locale) => {
+	if (typeof window === "undefined" || !_intlayer_config_built.routing?.rewrite) return;
+	const pathname = window.location.pathname;
+	const targetPath = (0, _intlayer_core_localization.getRewritePath)(pathname, locale, _intlayer_config_built.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 = require_client_installIntlayer.getIntlayerClient();
+	rewrite(client.locale);
+	return client.subscribe((newLocale) => {
+		rewrite(newLocale);
+	});
+};
+
+//#endregion
+exports.useRewriteURL = useRewriteURL;
+//# sourceMappingURL=useRewriteURL.cjs.map

package/dist/cjs/client/useRewriteURL.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRewriteURL.cjs","names":["routing","getIntlayerClient"],"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,CAACA,gCAAS,QAAS;CAExD,MAAM,WAAW,OAAO,SAAS;CACjC,MAAM,6DACJ,UACA,QACAA,gCAAS,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,SAASC,kDAAmB;AAGlC,SAAQ,OAAO,OAAO;AAEtB,QAAO,OAAO,WAAW,cAAc;AACrC,UAAQ,UAAU;GAClB"}