intor 2.3.3 → 2.3.5

package/dist/{src → core/src}/server/messages/load-messages.js

@@ -1,30 +1,29 @@
 import { loadLocalMessages } from './load-local-messages/load-local-messages.js';
 import { loadRemoteMessages } from './load-remote-messages/load-remote-messages.js';
 import { getLogger } from '../shared/logger/get-logger.js';
-import { resolveNamespaces } from '../../shared/utils/resolve-namespaces.js';
 
 /**
- * Load messages for a given locale and pathname.
+ * Load locale messages based on the resolved Intor configuration.
  *
- * - Resolve namespaces based on config and pathname.
- * - Support both **local local** and **remote API** loaders.
- * - Apply fallback locales if needed.
- * - Cache messages if enabled (handled by underlying loader, not this function directly).
+ * This function acts as a thin orchestration layer that:
+ *
+ * - Selects the appropriate message loader (local or remote)
+ * - Applies fallback locale resolution
+ * - Delegates caching and concurrency behavior to the underlying loader
+ *
+ * It does not perform message normalization or transformation itself.
  */
-const loadMessages = async ({ config, locale, pathname = "", extraOptions: { exts, messagesReader } = {}, allowCacheWrite = false, }) => {
+const loadMessages = async ({ config, locale, extraOptions: { exts, messagesReader } = {}, allowCacheWrite = false, }) => {
     const baseLogger = getLogger({ id: config.id, ...config.logger });
     const logger = baseLogger.child({ scope: "load-messages" });
+    // Guard: no loader configured
     if (!config.loader) {
         logger.warn("No loader options have been configured in the current config.");
         return;
     }
-    const { type, concurrency, rootDir } = config.loader;
-    const fallbackLocales = config.fallbackLocales[locale] || []; // fallback locales fro the pass-in target locale
-    const namespaces = resolveNamespaces({ config, pathname }); // Resolve namespaces with pathname
-    // Logs
-    if (logger.core.level === "debug") {
-        logger.debug("Starting to load messages.", { locale });
-    }
+    const { type, concurrency, rootDir, namespaces } = config.loader;
+    const fallbackLocales = config.fallbackLocales[locale] || [];
+    logger.info(`Loading messages for locale "${locale}".`);
     logger.trace("Starting to load messages with runtime context.", {
         loaderType: type,
         locale,
@@ -34,13 +33,13 @@ const loadMessages = async ({ config, locale, pathname = "", extraOptions: { ext
         concurrency: concurrency ?? 10,
     });
     let loadedMessages;
-    //====== loader type: local ======
+    // --- loader type: local
     if (type === "local") {
         loadedMessages = await loadLocalMessages({
-            rootDir,
             locale,
             fallbackLocales,
             namespaces,
+            rootDir,
             extraOptions: {
                 concurrency,
                 cacheOptions: config.cache,
@@ -51,25 +50,26 @@ const loadMessages = async ({ config, locale, pathname = "", extraOptions: { ext
             allowCacheWrite,
         });
     }
-    //====== loader type: remote ======
+    // --- loader type: remote
     else if (type === "remote") {
         // Fetch messages from remote
         loadedMessages = await loadRemoteMessages({
-            rootDir,
-            remoteUrl: config.loader.remoteUrl,
-            remoteHeaders: config.loader.remoteHeaders,
             locale,
             fallbackLocales,
             namespaces,
+            rootDir,
+            remoteUrl: config.loader.remoteUrl,
+            remoteHeaders: config.loader.remoteHeaders,
             extraOptions: {
                 cacheOptions: config.cache,
                 loggerOptions: { id: config.id, ...config.logger },
             },
+            allowCacheWrite,
         });
     }
     // No messages found
     if (!loadedMessages || Object.keys(loadedMessages).length === 0) {
-        logger.warn("No messages found.", { locale, namespaces });
+        logger.warn("No messages found.", { locale, fallbackLocales, namespaces });
     }
     return loadedMessages;
 };

package/dist/{src → core/src}/server/messages/load-remote-messages/fetch-locale-messages/fetch-locale-messages.js

@@ -7,7 +7,7 @@ import { getLogger } from '../../../shared/logger/get-logger.js';
  * - Validates that the returned JSON matches the expected `NamespaceMessages` structure.
  * - Uses `fetch` with `no-store` cache to always get fresh data.
  */
-const fetchLocaleMessages = async ({ remoteUrl, remoteHeaders, searchParams, locale, extraOptions: { loggerOptions } = {}, }) => {
+const fetchLocaleMessages = async ({ remoteUrl, remoteHeaders, searchParams, locale, extraOptions: { loggerOptions } = {}, signal, }) => {
     const baseLogger = getLogger({ ...loggerOptions });
     const logger = baseLogger.child({ scope: "fetch-locale-messages" });
     try {
@@ -24,6 +24,7 @@ const fetchLocaleMessages = async ({ remoteUrl, remoteHeaders, searchParams, loc
             method: "GET",
             headers,
             cache: "no-store",
+            signal,
         });
         if (!response.ok) {
             throw new Error(`HTTP error ${response.status} ${response.statusText}`);
@@ -37,6 +38,10 @@ const fetchLocaleMessages = async ({ remoteUrl, remoteHeaders, searchParams, loc
         return data;
     }
     catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            logger.debug("Fetching locale messages aborted.", { locale, remoteUrl });
+            return;
+        }
         logger.warn("Fetching locale messages failed.", {
             locale,
             remoteUrl,

package/dist/core/src/server/messages/load-remote-messages/load-remote-messages.js

@@ -0,0 +1,110 @@
+import { DEFAULT_CACHE_OPTIONS } from '../../../config/constants/cache.constants.js';
+import { fetchLocaleMessages } from './fetch-locale-messages/fetch-locale-messages.js';
+import { buildSearchParams } from './fetch-locale-messages/utils/build-search-params.js';
+import { getLogger } from '../../shared/logger/get-logger.js';
+import { getGlobalMessagesPool } from '../../shared/messages/global-messages-pool.js';
+import { normalizeCacheKey } from '../../../shared/utils/normalizers/normalize-cache-key.js';
+
+/**
+ * Load locale messages from a remote API.
+ *
+ * This function acts as the orchestration layer for remote message loading.
+ * It is responsible for:
+ *
+ * - Resolving fallback locales in order
+ * - Coordinating cache read / write behavior
+ * - Respecting abort signals across the entire async flow
+ *
+ * Network fetching and data validation are delegated to lower-level utilities.
+ */
+const loadRemoteMessages = async ({ pool = getGlobalMessagesPool(), rootDir, locale, fallbackLocales, namespaces, remoteUrl, remoteHeaders, extraOptions: { cacheOptions = DEFAULT_CACHE_OPTIONS, loggerOptions = { id: "default" }, } = {}, allowCacheWrite = false, signal, }) => {
+    const baseLogger = getLogger({ ...loggerOptions });
+    const logger = baseLogger.child({ scope: "load-remote-messages" });
+    // Abort early if the request has already been cancelled
+    if (signal?.aborted) {
+        logger.debug("Remote message loading aborted before fetch.");
+        return;
+    }
+    const start = performance.now();
+    logger.debug("Loading remote messages.", { remoteUrl });
+    // --- Cache key
+    const cacheKey = normalizeCacheKey([
+        loggerOptions.id,
+        "loaderType:remote",
+        rootDir,
+        locale,
+        (fallbackLocales ?? []).toSorted().join(","),
+        (namespaces ?? []).toSorted().join(","),
+    ]);
+    // --- Cache read --------------------------------------------------
+    if (cacheOptions.enabled && cacheKey) {
+        const cached = await pool?.get(cacheKey);
+        if (signal?.aborted) {
+            logger.debug("Remote message loading aborted after cache read.");
+            return;
+        }
+        if (cached) {
+            logger.debug("Messages cache hit.", { key: cacheKey });
+            return cached;
+        }
+    }
+    const candidateLocales = [locale, ...(fallbackLocales || [])];
+    let messages;
+    // Try each candidate locale in order and stop at the first successful result
+    for (let i = 0; i < candidateLocales.length; i++) {
+        const candidateLocale = candidateLocales[i];
+        const isLast = i === candidateLocales.length - 1;
+        try {
+            const fetched = await fetchLocaleMessages({
+                remoteUrl,
+                remoteHeaders,
+                locale: candidateLocale,
+                searchParams: buildSearchParams({ rootDir, namespaces }),
+                extraOptions: { loggerOptions },
+                signal,
+            });
+            // Stop at the first locale that yields non-empty messages
+            if (fetched && Object.values(fetched[candidateLocale] || {}).length > 0) {
+                messages = fetched;
+                break;
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+                logger.debug("Remote message loading aborted.");
+                return;
+            }
+            if (isLast) {
+                logger.warn("Failed to load messages for all candidate locales.", {
+                    locale,
+                    fallbackLocales,
+                });
+            }
+            else {
+                logger.warn(`Failed to fetch locale messages for "${candidateLocale}", trying next fallback.`);
+            }
+            logger.trace("Remote fetch error detail.", {
+                locale: candidateLocale,
+                error,
+            });
+        }
+    }
+    // --- Cache write --------------------------------------------------
+    if (cacheOptions.enabled && allowCacheWrite && cacheKey && messages) {
+        if (signal?.aborted) {
+            logger.debug("Remote message loading aborted before cache write.");
+            return;
+        }
+        await pool?.set(cacheKey, messages, cacheOptions.ttl);
+    }
+    // Final success log with resolved locale and timing
+    if (messages) {
+        logger.trace("Finished loading remote messages.", {
+            loadedLocale: messages ? Object.keys(messages)[0] : undefined,
+            duration: `${Math.round(performance.now() - start)} ms`,
+        });
+    }
+    return messages;
+};
+
+export { loadRemoteMessages };

package/dist/{src → core/src}/server/shared/logger/get-logger.js

@@ -1,22 +1,27 @@
 import { logry } from 'logry';
 import { getGlobalLoggerPool } from './global-logger-pool.js';
 
-const DEFAULT_FORMATTER_CONFIG = {
-    node: { meta: { compact: true }, lineBreaksAfter: 1 },
+const DEFAULT_FORMAT_CONFIG = {
+    timestamp: { withDate: false },
+};
+const DEFAULT_RENDER_CONFIG = {
+    timestamp: {},
+    id: { visible: true, prefix: "<", suffix: ">" },
+    meta: { lineBreaksAfter: 1 },
 };
 /**
  * Get a shared logger instance by id.
  * - Safe across hot reloads
  * - Prevents unbounded memory usage via soft LRU
  */
-function getLogger({ id = "default", formatterConfig, preset, ...options }) {
+function getLogger({ id = "default", formatConfig, renderConfig, preset, ...options }) {
     const pool = getGlobalLoggerPool();
     let logger = pool.get(id);
-    const useDefault = !formatterConfig && !preset;
     if (!logger) {
         logger = logry({
             id,
-            formatterConfig: useDefault ? DEFAULT_FORMATTER_CONFIG : formatterConfig,
+            formatConfig: !formatConfig && !preset ? DEFAULT_FORMAT_CONFIG : formatConfig,
+            renderConfig: !renderConfig && !preset ? DEFAULT_RENDER_CONFIG : renderConfig,
             preset,
             ...options,
         });

package/dist/core/src/server/shared/logger/global-logger-pool.js

@@ -0,0 +1,16 @@
+function getGlobalLoggerPool() {
+    if (!globalThis.__INTOR_LOGGER_POOL__) {
+        globalThis.__INTOR_LOGGER_POOL__ = new Map();
+    }
+    return globalThis.__INTOR_LOGGER_POOL__;
+}
+/**
+ * Optional: clear all cache
+ * Useful in tests or dynamic reloads.
+ */
+function clearLoggerPool() {
+    const pool = getGlobalLoggerPool();
+    pool.clear();
+}
+
+export { clearLoggerPool, getGlobalLoggerPool };

package/dist/core/src/server/shared/messages/global-messages-pool.js

@@ -0,0 +1,27 @@
+import Keyv from 'keyv';
+
+function getGlobalMessagesPool() {
+    if (!globalThis.__INTOR_MESSAGES_POOL__) {
+        globalThis.__INTOR_MESSAGES_POOL__ = new Keyv();
+    }
+    return globalThis.__INTOR_MESSAGES_POOL__;
+}
+/**
+ * Replace the global messages pool.
+ *
+ * - Intended for advanced usage (e.g. Redis, custom cache backends).
+ * - Must be called during application bootstrap.
+ */
+function setGlobalMessagesPool(pool) {
+    globalThis.__INTOR_MESSAGES_POOL__ = pool;
+}
+/**
+ * Optional: clear all cache
+ * - Useful in tests or dynamic reloads.
+ */
+function clearMessagesPool() {
+    const pool = getGlobalMessagesPool();
+    pool.clear();
+}
+
+export { clearMessagesPool, getGlobalMessagesPool, setGlobalMessagesPool };

package/dist/{src → core/src}/server/translator/get-translator.js

@@ -1,21 +1,12 @@
 import { Translator } from 'intor-translator';
 import { loadMessages } from '../messages/load-messages.js';
-import 'node:path';
-import 'node:perf_hooks';
-import 'p-limit';
-import '../../config/constants/cache.constants.js';
-import 'node:fs/promises';
-import 'logry';
-import 'lodash.merge';
-import 'keyv';
 
 // Implementation
 async function getTranslator(options) {
-    const { config, locale, pathname = "", preKey } = options;
+    const { config, locale, preKey } = options;
     const messages = await loadMessages({
         config,
         locale,
-        pathname,
         extraOptions: options.extraOptions,
     });
     // Create a Translator instance
@@ -26,6 +17,7 @@ async function getTranslator(options) {
         loadingMessage: config.translator?.loadingMessage,
         placeholder: config.translator?.placeholder,
         handlers: options.handlers,
+        plugins: options.plugins,
     });
     const props = { messages, locale };
     const scoped = translator.scoped(preKey);
@@ -33,6 +25,10 @@ async function getTranslator(options) {
         ...props,
         hasKey: preKey ? scoped.hasKey : translator.hasKey,
         t: preKey ? scoped.t : translator.t,
+        // NOTE:
+        // Return type is fully validated by overload signatures.
+        // Assertion here is intentional due to TS inference limitations.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
     };
 }
 

package/dist/core/src/shared/utils/deep-merge.js

@@ -0,0 +1,36 @@
+/**
+ * Deeply merges two objects.
+ * - Nested objects → merged recursively
+ * - Array / primitive → b overwrites a
+ */
+const deepMerge = (a, b) => {
+    if (!a && !b)
+        return undefined;
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    const result = { ...a };
+    for (const key in b) {
+        if (Object.prototype.hasOwnProperty.call(b, key)) {
+            const av = a[key];
+            const bv = b[key];
+            if (av &&
+                bv &&
+                typeof av === "object" &&
+                typeof bv === "object" &&
+                !Array.isArray(av) &&
+                !Array.isArray(bv)) {
+                // recursive merge
+                result[key] = deepMerge(av, bv);
+            }
+            else {
+                // overwrite with primitive or array
+                result[key] = bv;
+            }
+        }
+    }
+    return result;
+};
+
+export { deepMerge };

package/dist/{src/shared/utils → core/src/shared/utils/normalizers}/normalize-cache-key.js

@@ -1,16 +1,29 @@
 const CACHE_KEY_DELIMITER = "|";
-// Helper FC
 const sanitize = (k) => k
     .replaceAll(/[\u200B-\u200D\uFEFF]/g, "")
     .replaceAll(/[\r\n]/g, "")
     .trim();
+/**
+ * Normalizes a value into a stable cache key string.
+ *
+ * - Supports primitive values and structured array keys.
+ * - Produces deterministic output suitable for cache identifiers.
+ *
+ * Notes:
+ * - `null`, `undefined`, or empty arrays return `null`.
+ * - Special tokens are used for boolean, null, and undefined values
+ *   to preserve semantic differences.
+ */
 const normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
+    // Treat nullish values as "no cache key"
     if (key === null || key === undefined)
         return null;
     if (Array.isArray(key)) {
+        // Empty array produces no meaningful cache key
         if (key.length === 0)
             return null;
         const normalized = key.map((k) => {
+            // Preserve semantic differences for special values
             if (k === null)
                 return "__null";
             if (k === undefined)
@@ -19,10 +32,13 @@ const normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
                 return k ? "__true" : "__false";
             return sanitize(String(k));
         });
+        // Join segments into a single deterministic cache key
         return normalized.join(delimiter);
     }
+    // Normalize boolean primitives explicitly
     if (typeof key === "boolean")
         return key ? "__true" : "__false";
+    // Fallback: stringify primitive values
     return String(key);
 };
 

package/dist/{src/shared/utils/pathname → core/src/shared/utils/normalizers}/normalize-pathname.js

@@ -3,7 +3,7 @@
  *
  * - Trims leading and trailing whitespace (code points ≤ 32).
  * - Collapses consecutive slashes into a single slash.
- * - Ensures a leading slash and removes trailing slashes.
+ * - Ensures a single leading slash and removes redundant trailing slashes.
  * - Optionally removes the leading slash.
  * - Avoids intermediate array allocations for performance.
  */

package/dist/core/src/shared/utils/pathname/get-unprefixed-pathname.js

@@ -0,0 +1,39 @@
+import { normalizePathname } from '../normalizers/normalize-pathname.js';
+
+/**
+ * Returns a canonical, locale-agnostic pathname.
+ *
+ * @example
+ * ```ts
+ * // config.supportedLocales: ["en-US"]
+ * // config.routing.basePath: "/app"
+ * // config.routing.prefix: "all"
+ * getUnprefixedPathname(config, "/app/en-US/about" );
+ * // => "/about"
+ *```
+ */
+function getUnprefixedPathname(config, rawPathname) {
+    const { routing, supportedLocales } = config;
+    const { basePath } = routing;
+    // 1. Normalize pathname
+    const normalizedPathname = normalizePathname(rawPathname);
+    // 2. Strip basePath
+    let prefixedPathname = normalizedPathname;
+    if (basePath && normalizedPathname === basePath) {
+        prefixedPathname = "/";
+    }
+    else if (basePath && normalizedPathname.startsWith(basePath + "/")) {
+        prefixedPathname = normalizedPathname.slice(basePath.length);
+    }
+    // 3. Detect locale segment
+    const firstSegment = prefixedPathname.split("/").find(Boolean);
+    const locale = firstSegment && supportedLocales.includes(firstSegment)
+        ? firstSegment
+        : undefined;
+    // 4. Strip locale segment
+    return locale
+        ? prefixedPathname.slice(locale.length + 1) || "/"
+        : prefixedPathname;
+}
+
+export { getUnprefixedPathname };

package/dist/{src/adapters/next/shared/utils → core/src/shared/utils/pathname}/locale-prefix-pathname.js

@@ -1,32 +1,37 @@
-import { PREFIX_PLACEHOLDER } from '../../../../shared/constants/prefix-placeholder.js';
-import 'lodash.merge';
-import { normalizePathname } from '../../../../shared/utils/pathname/normalize-pathname.js';
+import { PREFIX_PLACEHOLDER } from '../../constants/prefix-placeholder.js';
+import { normalizePathname } from '../normalizers/normalize-pathname.js';
 
 /**
- * Converts a standardized pathname by applying the locale prefix according to the configured strategy.
+ * Applies routing prefix strategy by resolving the locale placeholder.
  *
- * Based on the `routing.prefix` setting in the config:
- * - "all": Always add the locale prefix.
- * - "except-default": Add the locale prefix unless the locale is the default.
- * - "none": Remove the locale prefix entirely.
+ * @example
+ * ```ts
+ * // config.routing.prefix: "all"
+ * localePrefixPathname({ config, pathname: "/app/{locale}/about", locale: "en-US" });
+ * // => /app/en-US/about
+ *
+ * // config.routing.prefix: "none"
+ * localePrefixPathname({ config, pathname: "/app/{locale}/about", locale: "en-US" });
+ * // => /app/about
+ * ```
  */
-const localePrefixPathname = ({ config, pathname: standardizedPathname, locale, }) => {
+const localePrefixPathname = (config, standardizedPathname, locale) => {
     const { routing } = config;
     const { prefix } = routing;
     if (prefix !== "none" && !locale) {
         throw new Error('No locale when using prefix "all", "except-default"');
     }
-    // context: "all"
+    // prefix: "all"
     if (prefix === "all") {
         return normalizePathname(standardizedPathname.replaceAll(PREFIX_PLACEHOLDER, locale));
     }
-    // context: "except-default"
+    // prefix: "except-default"
     if (prefix === "except-default") {
         return locale === config.defaultLocale
             ? normalizePathname(standardizedPathname.replaceAll(`/${PREFIX_PLACEHOLDER}`, ""))
             : normalizePathname(standardizedPathname.replaceAll(PREFIX_PLACEHOLDER, locale));
     }
-    // context: "none"
+    // prefix: "none"
     return normalizePathname(standardizedPathname.replaceAll(`/${PREFIX_PLACEHOLDER}`, ""));
 };
 

package/dist/core/src/shared/utils/pathname/localize-pathname.js

@@ -0,0 +1,36 @@
+import { getUnprefixedPathname } from './get-unprefixed-pathname.js';
+import { localePrefixPathname } from './locale-prefix-pathname.js';
+import { standardizePathname } from './standardize-pathname.js';
+
+/**
+ * Localizes a pathname by composing canonicalization,
+ * standardization, and locale prefix strategies.
+ *
+ * @example
+ * ```ts
+ * // config.supportedLocales: ["en-US"]
+ * // config.routing.basePath: "/app"
+ * // config.routing.prefix: "all"
+ * localePrefixPathname({ config, pathname: "/app/en-US/about", locale: "en-US" });
+ * // => {
+ * //   unprefixedPathname: '/about',
+ * //   standardizedPathname: '/app/{locale}/about',
+ * //   localizedPathname: '/app/en-US/about'
+ * // }
+ * ```
+ */
+const localizePathname = (config, rawPathname, locale) => {
+    // 1. Canonicalize: extract basePath and strip locale
+    const unprefixedPathname = getUnprefixedPathname(config, rawPathname);
+    // 2. Standardize: build a pathname with locale placeholder
+    const standardizedPathname = standardizePathname(config, unprefixedPathname);
+    // 3. Apply strategy: resolve locale prefix based on routing rules
+    const localizedPathname = localePrefixPathname(config, standardizedPathname, locale);
+    return {
+        unprefixedPathname,
+        standardizedPathname,
+        localizedPathname,
+    };
+};
+
+export { localizePathname };

package/dist/{src → core/src}/shared/utils/pathname/standardize-pathname.js

@@ -1,25 +1,25 @@
 import { PREFIX_PLACEHOLDER } from '../../constants/prefix-placeholder.js';
-import { normalizePathname } from './normalize-pathname.js';
+import { normalizePathname } from '../normalizers/normalize-pathname.js';
 
 /**
- * Standardize a pathname by prepending the base path and prefix placeholder,
- * then normalize the result to remove redundant slashes.
+ * Standardizes a canonical pathname by applying the base path
+ * and injecting the locale placeholder.
  *
+ * @example
  * ```ts
+ * // routing.basePath: "/app",
  * standardizePathname({ config, pathname: "/cms" });
- * // basePath: "/asd/qwe"
- * // prefixPlaceHolder: "{locale}"
- * => "/asd/qwe/{locale}/cms"
+ * // => "/app/{locale}/cms"
  * ```
  */
-const standardizePathname = ({ config, pathname, }) => {
+const standardizePathname = (config, unprefixedPathname) => {
     const { routing } = config;
     const { basePath } = routing;
     // Normalize each segment before join to avoid redundant slashes
     const parts = [
         normalizePathname(basePath),
         PREFIX_PLACEHOLDER,
-        normalizePathname(pathname),
+        normalizePathname(unprefixedPathname),
     ];
     // Avoid double slashes between segments
     const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");

package/dist/next/export/next/index.js

@@ -0,0 +1,4 @@
+export { Link } from '../../src/adapters/next/navigation/link.js';
+export { usePathname } from '../../src/adapters/next/navigation/use-pathname.js';
+export { useRouter } from '../../src/adapters/next/navigation/use-router.js';
+export { redirect } from '../../src/adapters/next/navigation/redirect.js';

package/dist/{exports → next/export}/next/proxy/index.js

@@ -1,2 +1 @@
 export { intorProxy as intorMiddleware, intorProxy } from '../../../src/adapters/next/proxy/intor-proxy.js';
-export { PATHNAME_HEADER_NAME } from '../../../src/adapters/next/shared/constants/pathname-header-name.js';

package/dist/next/export/next/server/index.js

@@ -0,0 +1,2 @@
+export { getLocale } from '../../../src/adapters/next/server/get-locale.js';
+export { getTranslator } from '../../../src/adapters/next/server/get-translator.js';