intor 2.3.6 → 2.3.7

package/dist/types/src/routing/locale/resolve-locale.d.ts

@@ -1,5 +1,5 @@
+import type { LocaleContext, ResolvedLocale } from "./types";
 import type { IntorResolvedConfig } from "../../config";
-import type { LocaleContext, ResolvedLocale } from "../../routing/locale/types";
 /**
  * Resolve the final locale based on routing configuration.
  *

package/dist/types/src/routing/locale/types.d.ts

@@ -1,4 +1,4 @@
-import type { RoutingLocaleSource } from "../../shared/types/routing";
+import type { RoutingLocaleSource } from "../../core";
 /** Context for locale resolution. */
 export interface LocaleContext {
     /** Locale extracted from the URL pathname, if present */

package/dist/types/src/routing/pathname/resolve-pathname.d.ts

@@ -1,5 +1,5 @@
+import type { PathnameContext, ResolvedPathname } from "./types";
 import type { IntorResolvedConfig } from "../../config";
-import type { PathnameContext, ResolvedPathname } from "../../routing/pathname/types";
 /**
  * Resolve the final pathname based on routing configuration.
  *

package/dist/types/src/routing/pathname/types.d.ts

@@ -1,4 +1,4 @@
-import type { RoutingLocaleSource } from "../../shared/types/routing";
+import type { RoutingLocaleSource } from "../../core";
 /**
  * Context for pathname processing.
  *

package/dist/types/src/routing/resolve-navigation-target.d.ts

@@ -1,4 +1,4 @@
-import type { IntorResolvedConfig } from "../config/types/intor-config.types";
+import type { IntorResolvedConfig } from "../config";
 import type { Locale } from "intor-translator";
 export interface NavigationTarget {
     /** Locale selected for this navigation */

package/dist/types/src/routing/resolve-routing.d.ts

@@ -1,5 +1,5 @@
 import type { IntorResolvedConfig } from "../config";
-import type { RoutingLocaleSource } from "../shared/types/routing";
+import type { RoutingLocaleSource } from "../core";
 interface ResolveRoutingResult {
     /** Final resolved locale */
     locale: string;

package/dist/types/src/server/helpers/index.d.ts

@@ -1 +1 @@
-export { loadLocalMessagesFromUrl } from "./local-messages-from-url";
+export { loadMessagesFromUrl } from "./local-messages-from-url";

package/dist/types/src/server/helpers/local-messages-from-url.d.ts

@@ -1,8 +1,18 @@
-import type { LoadLocalMessagesExtraOptions } from "../../server/messages/load-local-messages";
+import type { CacheResolvedOptions, LoggerOptions } from "../../config";
+import type { MessagesPool, MessagesReader } from "../../core";
+export interface LoadMessagesFromUrlOptiosn {
+    concurrency?: number;
+    exts?: string[];
+    messagesReader?: MessagesReader;
+    pool?: MessagesPool;
+    cacheOptions?: CacheResolvedOptions;
+    allowCacheWrite?: boolean;
+    loggerOptions?: LoggerOptions;
+}
 /**
- * Load local locale messages from a URL-based query protocol.
+ * Load locale messages from a URL-based query protocol.
  *
- * - A convenience helper for exposing local messages through a URL-accessible interface.
+ * - This helper is intended for building custom HTTP endpoints
  *
  * @example
  * ```ts
@@ -15,7 +25,7 @@ import type { LoadLocalMessagesExtraOptions } from "../../server/messages/load-l
  *   "&fallbackLocales=zh-TW"
  * );
  *
- * const messages = await loadLocalMessagesFromUrl(url);
+ * const messages = await loadMessagesFromUrl(url);
  * ```
  */
-export declare function loadLocalMessagesFromUrl(url: URL, extraOptions?: LoadLocalMessagesExtraOptions): Promise<import("intor-translator").LocaleMessages | undefined>;
+export declare function loadMessagesFromUrl(url: URL, options?: LoadMessagesFromUrlOptiosn): Promise<import("intor-translator").LocaleMessages | undefined>;

package/dist/types/src/server/index.d.ts

@@ -1,6 +1,4 @@
 export { intor, type IntorResult } from "./intor";
-export { loadMessages, isValidMessages, type Messages, type MessagesReader, } from "./messages";
-export { getTranslator } from "./translator";
-export { clearLoggerPool } from "./shared/logger/global-logger-pool";
-export { clearMessagesPool, setGlobalMessagesPool, } from "./shared/messages/global-messages-pool";
-export { loadLocalMessagesFromUrl } from "./helpers";
+export { loadMessages } from "./messages";
+export { getTranslator, type GetTranslatorParams, type TranslatorInstanceServer, } from "./translator";
+export { loadMessagesFromUrl } from "./helpers";

package/dist/types/src/server/intor/intor.d.ts

@@ -1,7 +1,7 @@
+import type { IntorResult, LocaleResolver } from "./types";
 import type { IntorResolvedConfig } from "../../config";
-import type { GetLocale, IntorResult } from "../../server/intor/types";
-import type { MessagesReader } from "../../server/messages";
-import type { GenConfigKeys } from "../../shared/types";
+import type { MessagesReader } from "../../core";
+import type { GenConfigKeys, GenLocale } from "../../core";
 /**
  * Entry point for initializing Intor.
  *
@@ -14,7 +14,7 @@ import type { GenConfigKeys } from "../../shared/types";
  * This function does not perform routing decisions itself.
  * Locale resolution is delegated to the provided `getLocale` implementation.
  */
-export declare const intor: <CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, getLocale: GetLocale, loadMessagesOptions?: {
+export declare const intor: <CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, getLocale: LocaleResolver<CK> | GenLocale<CK>, loadMessagesOptions?: {
     exts?: string[];
     messagesReader?: MessagesReader;
 }) => Promise<IntorResult<CK>>;

package/dist/types/src/server/intor/types.d.ts

@@ -1,9 +1,9 @@
-import type { IntorResolvedConfig } from "../../config/types/intor-config.types";
-import type { GenConfigKeys, GenLocale } from "../../shared/types/generated";
+import type { IntorResolvedConfig } from "../../config";
+import type { GenConfigKeys, GenLocale } from "../../core";
 import type { LocaleMessages } from "intor-translator";
-export type GetLocale<CK extends GenConfigKeys = "__default__"> = GenLocale<CK> | ((config: IntorResolvedConfig) => GenLocale<CK> | Promise<GenLocale<CK>>);
+export type LocaleResolver<CK extends GenConfigKeys = "__default__"> = (config: IntorResolvedConfig) => GenLocale<CK> | Promise<GenLocale<CK>>;
 export interface IntorResult<CK extends GenConfigKeys = "__default__"> {
     config: IntorResolvedConfig;
     initialLocale: GenLocale<CK>;
-    messages: LocaleMessages;
+    initialMessages: Readonly<LocaleMessages>;
 }

package/dist/types/src/server/messages/index.d.ts

@@ -1,3 +1 @@
 export { loadMessages } from "./load-messages";
-export { isValidMessages } from "./shared/utils/is-valid-messages";
-export type { Messages, MessagesReader } from "./shared/types";

package/dist/types/src/server/messages/load-local-messages/index.d.ts

@@ -1,2 +1,2 @@
-export type { LoadLocalMessagesParams, LoadLocalMessagesExtraOptions, } from "./types";
+export type { LoadLocalMessagesParams } from "./types";
 export { loadLocalMessages } from "./load-local-messages";

package/dist/types/src/server/messages/load-local-messages/load-local-messages.d.ts

@@ -12,4 +12,4 @@ import type { LocaleMessages } from "intor-translator";
  *
  * File system traversal, parsing, and message validation are delegated to lower-level utilities.
  */
-export declare const loadLocalMessages: ({ pool, rootDir, locale, fallbackLocales, namespaces, extraOptions: { concurrency, cacheOptions, loggerOptions, exts, messagesReader, }, allowCacheWrite, }: LoadLocalMessagesParams) => Promise<LocaleMessages | undefined>;
+export declare const loadLocalMessages: ({ locale, fallbackLocales, namespaces, rootDir, concurrency, exts, messagesReader, pool, cacheOptions, allowCacheWrite, loggerOptions, }: LoadLocalMessagesParams) => Promise<LocaleMessages | undefined>;

package/dist/types/src/server/messages/load-local-messages/read-locale-messages/collect-file-entries/collect-file-entries.d.ts

@@ -1,5 +1,5 @@
 import type { CollectFileEntriesParams } from "./types";
-import type { FileEntry } from "../../../../../server/messages/load-local-messages/read-locale-messages";
+import type { FileEntry } from "../types";
 /**
  * Recursively collects all message files under a given root directory.
  *
@@ -17,4 +17,4 @@ import type { FileEntry } from "../../../../../server/messages/load-local-messag
  * }, ... ];
  * ```
  */
-export declare function collectFileEntries({ readdir, limit, rootDir, namespaces, extraOptions: { exts, loggerOptions }, }: CollectFileEntriesParams): Promise<FileEntry[]>;
+export declare function collectFileEntries({ readdir, namespaces, rootDir, limit, extraOptions: { exts, loggerOptions }, }: CollectFileEntriesParams): Promise<FileEntry[]>;

package/dist/types/src/server/messages/load-local-messages/read-locale-messages/collect-file-entries/types.d.ts

@@ -1,15 +1,13 @@
-import type { LoggerOptions } from "../../../../../config/types/logger.types";
+import type { LoggerOptions } from "../../../../../config";
 import type fs from "node:fs/promises";
 import type { LimitFunction } from "p-limit";
 export interface CollectFileEntriesParams {
     readdir?: (typeof fs)["readdir"];
-    limit: LimitFunction;
-    rootDir: string;
     namespaces?: string[];
-    extraOptions?: {
+    rootDir: string;
+    limit: LimitFunction;
+    extraOptions: {
         exts?: string[];
-        loggerOptions?: LoggerOptions & {
-            id?: string;
-        };
+        loggerOptions: LoggerOptions;
     };
 }

package/dist/types/src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/parse-file-entries.d.ts

@@ -1,5 +1,5 @@
 import type { ParseFileEntriesParams } from "./types";
-import type { Messages } from "../../../../../server/messages/shared/types";
+import type { Messages } from "../../../../../core";
 /**
  * Parse locale message files (JSON or custom formats) into a unified LocaleMessages object.
  *

package/dist/types/src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/types.d.ts

@@ -1,15 +1,13 @@
-import type { LoggerOptions } from "../../../../../config/types/logger.types";
-import type { FileEntry } from "../../../../../server/messages/load-local-messages/read-locale-messages/types";
-import type { MessagesReader, Messages } from "../../../../../server/messages/shared/types";
+import type { FileEntry } from "../types";
+import type { LoggerOptions } from "../../../../../config";
+import type { MessagesReader, Messages } from "../../../../../core";
 import type { LimitFunction } from "p-limit";
 export interface ParseFileEntriesParams {
     fileEntries: FileEntry[];
     limit: LimitFunction;
-    extraOptions?: {
-        loggerOptions?: LoggerOptions & {
-            id?: string;
-        };
+    extraOptions: {
         messagesReader?: MessagesReader;
+        loggerOptions: LoggerOptions;
     };
 }
 export interface ParsedFileEntries {

package/dist/types/src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/utils/json-reader.d.ts

@@ -1,4 +1,4 @@
-import type { Messages } from "../../../../../../server/messages/shared/types";
+import type { Messages } from "../../../../../../core";
 import fs from "node:fs/promises";
 /**
  *  Read & parse a JSON file

package/dist/types/src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/utils/nest-object-from-path.d.ts

@@ -1,4 +1,4 @@
-import type { Messages } from "../../../../../../server/messages/shared/types";
+import type { Messages } from "../../../../../../core";
 /**
  * Wraps a value inside nested objects according to a given path.
  *

package/dist/types/src/server/messages/load-local-messages/read-locale-messages/read-locale-messages.d.ts

@@ -1,4 +1,4 @@
-import type { ReadLocaleMessagesParams } from "../../../../server/messages/load-local-messages/read-locale-messages/types";
+import type { ReadLocaleMessagesParams } from "./types";
 import type { LocaleMessages } from "intor-translator";
 /**
  * Read messages for a specific locale from the file system.
@@ -7,4 +7,4 @@ import type { LocaleMessages } from "intor-translator";
  * 2. Parses each file into a messages object.
  * 3. Wraps the parsed messages under the locale key.
  */
-export declare const readLocaleMessages: ({ limit, rootDir, locale, namespaces, extraOptions: { exts, messagesReader, loggerOptions }, }: ReadLocaleMessagesParams) => Promise<LocaleMessages>;
+export declare const readLocaleMessages: ({ locale, namespaces, rootDir, limit, extraOptions: { exts, messagesReader, loggerOptions }, }: ReadLocaleMessagesParams) => Promise<LocaleMessages>;

package/dist/types/src/server/messages/load-local-messages/read-locale-messages/types.d.ts

@@ -1,5 +1,5 @@
-import type { LoggerOptions } from "../../../../config/types/logger.types";
-import type { MessagesReader } from "../../../../server/messages/shared/types";
+import type { LoggerOptions } from "../../../../config";
+import type { MessagesReader } from "../../../../core";
 import type { LimitFunction } from "p-limit";
 export interface FileEntry {
     namespace: string;
@@ -9,15 +9,13 @@ export interface FileEntry {
     basename: string;
 }
 export interface ReadLocaleMessagesParams {
-    limit: LimitFunction;
-    rootDir?: string;
     locale: string;
     namespaces?: string[];
-    extraOptions?: {
-        loggerOptions?: LoggerOptions & {
-            id?: string;
-        };
+    rootDir?: string;
+    limit: LimitFunction;
+    extraOptions: {
         exts?: string[];
         messagesReader?: MessagesReader;
+        loggerOptions: LoggerOptions;
     };
 }

package/dist/types/src/server/messages/load-local-messages/types.d.ts

@@ -1,22 +1,15 @@
-import type { CacheResolvedOptions } from "../../../config/types/cache.types";
-import type { LoggerOptions } from "../../../config/types/logger.types";
-import type { MessagesReader } from "../../../server/messages/shared/types";
-import type { MessagesPool } from "../../../server/shared/messages/global-messages-pool";
-export interface LoadLocalMessagesExtraOptions {
-    concurrency?: number;
-    cacheOptions?: CacheResolvedOptions;
-    loggerOptions?: LoggerOptions & {
-        id?: string;
-    };
-    exts?: string[];
-    messagesReader?: MessagesReader;
-}
+import type { CacheResolvedOptions, LoggerOptions } from "../../../config";
+import type { MessagesPool, MessagesReader } from "../../../core";
 export interface LoadLocalMessagesParams {
-    pool?: MessagesPool;
-    rootDir?: string;
     locale: string;
     fallbackLocales?: string[];
     namespaces?: string[];
-    extraOptions?: LoadLocalMessagesExtraOptions;
+    rootDir?: string;
+    concurrency?: number;
+    exts?: string[];
+    messagesReader?: MessagesReader;
+    pool?: MessagesPool;
+    cacheOptions: CacheResolvedOptions;
     allowCacheWrite?: boolean;
+    loggerOptions: LoggerOptions;
 }

package/dist/types/src/server/messages/load-messages.d.ts

@@ -1,5 +1,5 @@
-import type { LoadMessagesOptions, LoadMessagesResult } from "../../server/messages/types";
-import type { GenConfigKeys } from "../../shared/types/generated";
+import type { LoadMessagesParams } from "./types";
+import type { LocaleMessages } from "intor-translator";
 /**
  * Load locale messages based on the resolved Intor configuration.
  *
@@ -11,4 +11,4 @@ import type { GenConfigKeys } from "../../shared/types/generated";
  *
  * It does not perform message normalization or transformation itself.
  */
-export declare const loadMessages: <CK extends GenConfigKeys = "__default__">({ config, locale, extraOptions: { exts, messagesReader }, allowCacheWrite, }: LoadMessagesOptions) => LoadMessagesResult<CK>;
+export declare const loadMessages: ({ config, locale, extraOptions: { exts, messagesReader }, allowCacheWrite, }: LoadMessagesParams) => Promise<LocaleMessages | undefined>;

package/dist/types/src/server/messages/types.d.ts

@@ -1,14 +1,20 @@
-import type { IntorResolvedConfig } from "../../config/types/intor-config.types";
-import type { MessagesReader } from "../../server/messages/shared/types";
-import type { GenConfigKeys, GenMessages } from "../../shared/types/generated";
+import type { IntorResolvedConfig } from "../../config";
+import type { MessagesReader } from "../../core";
 import type { Locale } from "intor-translator";
-export type LoadMessagesOptions = {
+export type LoadMessagesParams = {
     config: IntorResolvedConfig;
     locale: Locale;
     extraOptions?: {
         exts?: string[];
         messagesReader?: MessagesReader;
     };
+    /**
+     * Controls whether this load operation is allowed to write into
+     * the shared messages cache.
+     *
+     * This is intended for internal orchestration (e.g. `intor`)
+     * to act as the primary cache writer, while other helpers
+     * may perform read-only loads.
+     */
     allowCacheWrite?: boolean;
 };
-export type LoadMessagesResult<CK extends GenConfigKeys = "__default__"> = Promise<GenMessages<CK> | undefined>;

package/dist/types/src/server/translator/get-translator.d.ts

@@ -1,22 +1,8 @@
-import type { IntorResolvedConfig } from "../../config/types/intor-config.types";
-import type { GenConfigKeys, GenLocale, GenMessages } from "../../shared/types/generated";
-import type { TranslatorInstance } from "../../shared/types/translator-instance";
+import type { TranslatorInstanceServer } from "./translator-instance";
+import type { IntorResolvedConfig } from "../../config";
+import type { MessagesReader, GenConfigKeys, GenLocale, GenMessages } from "../../core";
 import type { LocalizedNodeKeys, TranslateHandlers, TranslateHook, TranslatorPlugin } from "intor-translator";
-import { type MessagesReader } from "../../server/messages";
-/**
- * Create a translator instance for a specific locale.
- */
-export declare function getTranslator<CK extends GenConfigKeys = "__default__">(options: {
-    config: IntorResolvedConfig;
-    locale: GenLocale<CK>;
-    handlers?: TranslateHandlers;
-    plugins?: (TranslatorPlugin | TranslateHook)[];
-    extraOptions?: {
-        exts?: string[];
-        messagesReader?: MessagesReader;
-    };
-}): Promise<TranslatorInstance<GenMessages<CK>>>;
-export declare function getTranslator<CK extends GenConfigKeys = "__default__", PK extends string = LocalizedNodeKeys<GenMessages<CK>>>(options: {
+export interface GetTranslatorParams<CK extends GenConfigKeys = "__default__"> {
     config: IntorResolvedConfig;
     locale: GenLocale<CK>;
     handlers?: TranslateHandlers;
@@ -25,5 +11,11 @@ export declare function getTranslator<CK extends GenConfigKeys = "__default__",
         exts?: string[];
         messagesReader?: MessagesReader;
     };
+}
+/**
+ * Create a translator instance for server-side usage.
+ */
+export declare function getTranslator<CK extends GenConfigKeys = "__default__">(params: GetTranslatorParams<CK>): Promise<TranslatorInstanceServer<GenMessages<CK>>>;
+export declare function getTranslator<CK extends GenConfigKeys = "__default__", PK extends string = LocalizedNodeKeys<GenMessages<CK>>>(params: GetTranslatorParams<CK> & {
     preKey?: PK;
-}): Promise<TranslatorInstance<GenMessages<CK>, PK>>;
+}): Promise<TranslatorInstanceServer<GenMessages<CK>, PK>>;

package/dist/types/src/server/translator/index.d.ts

@@ -1 +1,2 @@
-export { getTranslator } from "./get-translator";
+export { getTranslator, type GetTranslatorParams } from "./get-translator";
+export type { TranslatorInstanceServer } from "./translator-instance";

package/dist/types/src/server/translator/translator-instance.d.ts

@@ -0,0 +1,8 @@
+import type { KeyMode, TranslatorInstance } from "../../core";
+import { type Locale, type LocaleMessages } from "intor-translator";
+export type TranslatorInstanceServer<M extends LocaleMessages, PK extends string | undefined = undefined, Mode extends KeyMode = "auto"> = TranslatorInstance<M, PK, Mode> & {
+    /** `messages`: The message object containing all translations. */
+    messages: M;
+    /** Current locale in use. */
+    locale: Locale<M>;
+};

package/dist/vue/export/vue/index.js

@@ -0,0 +1,6 @@
+export { IntorProvider } from '../../src/client/vue/provider/intor-provider.js';
+import 'vue';
+export { useTranslator } from '../../src/client/vue/translator/use-translator.js';
+export { T } from '../../src/client/vue/translator/t.js';
+export { useLoadMessages } from '../../src/client/vue/helpers/use-load-messages.js';
+export { getClientLocale } from '../../src/client/helpers/get-client-locale.js';

package/dist/vue/src/client/helpers/get-client-locale.js

@@ -0,0 +1,27 @@
+import '../../core/error/intor-error.js';
+import { normalizeLocale } from '../../core/utils/normalizers/normalize-locale.js';
+import 'logry';
+import 'keyv';
+import { detectBrowserLocale } from '../shared/utils/locale/detect-browser-locale.js';
+import { getLocaleCookieBrowser } from '../shared/utils/locale/get-locale-cookie-browser.js';
+
+/**
+ * Resolve the locale in a client-only environment.
+ *
+ * This helper is intended for pure CSR setups (e.g. Vite).
+ *
+ * For framework-based apps, prefer `useTranslator()`.
+ *
+ * - Client-side only
+ */
+function getClientLocale(config) {
+    const { defaultLocale, supportedLocales, cookie } = config;
+    // Locale from browser cookie
+    const cookieLocale = getLocaleCookieBrowser(cookie.name);
+    // Locale from browser preference
+    const browserLocale = detectBrowserLocale();
+    const localeCandidate = cookieLocale || browserLocale;
+    return normalizeLocale(localeCandidate, supportedLocales) || defaultLocale;
+}
+
+export { getClientLocale };

package/dist/vue/src/client/shared/messages/create-refetch-messages.js

@@ -0,0 +1,61 @@
+import '../../../core/error/intor-error.js';
+import { deepMerge } from '../../../core/utils/deep-merge.js';
+import { resolveLoaderOptions } from '../../../core/utils/resolve-loader-options.js';
+import 'logry';
+import { loadRemoteMessages } from '../../../core/messages/load-remote-messages/load-remote-messages.js';
+import 'keyv';
+
+/**
+ * Creates a framework-agnostic message refetcher.
+ *
+ * - At most one remote request is active at any time
+ * - Previous in-flight requests are aborted on subsequent calls
+ * - State updates are applied only for the latest, non-aborted request
+ */
+const createRefetchMessages = ({ config, onLoadingStart, onLoadingEnd, onMessages, }) => {
+    // Tracks the currently active remote request for this refetcher instance
+    let controller = null;
+    return async function refetchMessages(newLocale) {
+        // No-op when remote loading is not enabled
+        const loader = resolveLoaderOptions(config);
+        if (!loader || loader.type !== "remote")
+            return;
+        // Abort previous request
+        controller?.abort();
+        const currentController = new AbortController();
+        controller = currentController;
+        onLoadingStart?.();
+        try {
+            const loadedMessages = await loadRemoteMessages({
+                // --- Messages Scope ---
+                locale: newLocale,
+                fallbackLocales: config.fallbackLocales[newLocale] || [],
+                namespaces: loader.namespaces,
+                rootDir: loader.rootDir,
+                // --- Remote Source ---
+                url: loader.url,
+                headers: loader.headers,
+                signal: currentController.signal,
+                // --- Caching ---
+                cacheOptions: config.cache,
+                // --- Observability ---
+                loggerOptions: config.logger,
+            });
+            // Apply state updates only when this request is still the active one
+            // and has not been aborted.
+            if (controller === currentController &&
+                !currentController.signal.aborted) {
+                onMessages?.(deepMerge(config.messages, loadedMessages));
+            }
+        }
+        finally {
+            // Clear loading state only if this request is still the active one
+            if (controller === currentController &&
+                !currentController.signal.aborted) {
+                onLoadingEnd?.();
+            }
+        }
+    };
+};
+
+export { createRefetchMessages };

package/dist/vue/src/client/shared/utils/build-cookie-string.js

@@ -0,0 +1,30 @@
+/**
+ * Build a serialized cookie string.
+ */
+const buildCookieString = (cookieOptions, value) => {
+    const { name, maxAge, path, domain, sameSite, secure } = cookieOptions;
+    // Cookie name and encoded value
+    const parts = [`${name}=${encodeURIComponent(value)}`];
+    // Add expiration and max-age if provided
+    if (maxAge) {
+        const expires = new Date(Date.now() + maxAge * 1000).toUTCString();
+        parts.push(`expires=${expires}`, `max-age=${maxAge}`);
+    }
+    // Set path (default to "/")
+    parts.push(`path=${path ?? "/"}`);
+    // Add domain if specified
+    if (domain) {
+        parts.push(`domain=${domain}`);
+    }
+    // Add SameSite policy (e.g., Lax, Strict)
+    if (sameSite) {
+        parts.push(`SameSite=${sameSite[0].toUpperCase()}${sameSite.slice(1).toLowerCase()}`);
+    }
+    // Add Secure flag if not explicitly disabled
+    if (secure !== false) {
+        parts.push(`Secure`);
+    }
+    return parts.join("; ");
+};
+
+export { buildCookieString };

package/dist/vue/src/client/shared/utils/locale/detect-browser-locale.js

@@ -0,0 +1,12 @@
+/**
+ * Detect the preferred locale from the browser.
+ *
+ * - Client-side only
+ */
+function detectBrowserLocale() {
+    if (typeof navigator === "undefined")
+        return undefined;
+    return navigator.languages?.[0] || navigator.language || undefined;
+}
+
+export { detectBrowserLocale };

package/dist/vue/src/client/shared/utils/locale/get-locale-cookie-browser.js

@@ -0,0 +1,16 @@
+/**
+ * Gets the locale value from the browser cookie.
+ *
+ * - Client-side only
+ */
+function getLocaleCookieBrowser(cookieName) {
+    if (typeof document === "undefined")
+        return undefined;
+    const cookies = document.cookie.split(";").map((c) => c.trim());
+    const entry = cookies.find((c) => c.startsWith(`${cookieName}=`));
+    if (!entry)
+        return undefined;
+    return decodeURIComponent(entry.slice(cookieName.length + 1));
+}
+
+export { getLocaleCookieBrowser };

package/dist/vue/src/client/shared/utils/locale/set-document-locale.js

@@ -0,0 +1,12 @@
+/**
+ * Sets the document language attribute.
+ *
+ * - Client-side only
+ */
+function setDocumentLocale(locale) {
+    if (typeof document === "undefined")
+        return;
+    document.documentElement.lang = locale;
+}
+
+export { setDocumentLocale };

package/dist/vue/src/client/shared/utils/locale/set-locale-cookie-browser.js

@@ -0,0 +1,18 @@
+import { buildCookieString } from '../build-cookie-string.js';
+
+/**
+ * Persist locale to browser cookie.
+ *
+ * - Client-side only
+ */
+const setLocaleCookieBrowser = (cookieOptions, locale) => {
+    if (typeof document === "undefined")
+        return;
+    // Skip when cookie persistence is disabled
+    if (!cookieOptions.enabled || !cookieOptions.persist)
+        return;
+    // Build and apply the cookie string
+    document.cookie = buildCookieString(cookieOptions, locale);
+};
+
+export { setLocaleCookieBrowser };