tanstack-start-intl 0.0.0-alpha.0

package/README.md

@@ -0,0 +1,122 @@
+# tanstack-start-intl
+
+Internationalization (i18n) for [TanStack Start](https://tanstack.com/start), built on [use-intl](https://github.com/amannn/next-intl/tree/main/packages/use-intl) and aligned with [next-intl](https://next-intl.dev) semantics.
+
+## Setup
+
+### 1. Install
+
+```bash
+pnpm add tanstack-start-intl use-intl
+# peer: @tanstack/react-router, react
+```
+
+### 2. Config alias
+
+In your Vite or TanStack Start config, add an alias so the package can load your request config:
+
+```ts
+// e.g. app.config.ts or vite.config.ts
+export default defineConfig({
+  resolve: {
+    alias: {
+      'tanstack-start-intl/config': resolve(__dirname, 'src/i18n/request.ts')
+    }
+  }
+});
+```
+
+### 3. Request config
+
+Create `src/i18n/request.ts` (or your chosen path):
+
+```ts
+import { getRequestConfig } from 'tanstack-start-intl/server';
+import { hasLocale } from 'tanstack-start-intl';
+import { routing } from './routing';
+
+export default getRequestConfig(async ({ requestLocale }) => {
+  const requested = await requestLocale;
+  const locale = hasLocale(routing.locales, requested)
+    ? requested
+    : routing.defaultLocale;
+
+  return {
+    locale,
+    messages: (await import(`../../messages/${locale}.json`)).default
+  };
+});
+```
+
+### 4. Routing config
+
+Create `src/i18n/routing.ts`:
+
+```ts
+import { defineRouting } from 'tanstack-start-intl/routing';
+
+export const routing = defineRouting({
+  locales: ['en', 'fr'],
+  defaultLocale: 'en',
+  pathnames: {
+    '/': '/',
+    '/about': { en: '/about', fr: '/a-propos' }
+  }
+});
+```
+
+### 5. Locale layout
+
+In your locale route (e.g. `src/routes/$locale.tsx`), set the request locale and wrap with the provider:
+
+```tsx
+import { createFileRoute } from '@tanstack/react-router';
+import { setRequestLocale, getRequestConfig } from 'tanstack-start-intl/server';
+import { NextIntlClientProvider, hasLocale } from 'tanstack-start-intl';
+import { routing } from '@/i18n/routing';
+
+export const Route = createFileRoute('/$locale')({
+  component: LocaleLayout
+});
+
+async function LocaleLayout() {
+  const { locale } = Route.useParams();
+  if (!hasLocale(routing.locales, locale)) {
+    throw new Error('Invalid locale');
+  }
+  setRequestLocale(locale);
+  const config = await getRequestConfig({
+    requestLocale: Promise.resolve(locale)
+  });
+
+  return (
+    <NextIntlClientProvider locale={config.locale} messages={config.messages}>
+      <Outlet />
+    </NextIntlClientProvider>
+  );
+}
+```
+
+### 6. Navigation (optional)
+
+If you use pathnames and locale prefix, create navigation helpers:
+
+```tsx
+// src/i18n/navigation.ts
+import { createNavigation } from 'tanstack-start-intl';
+import { routing } from './routing';
+
+export const { Link, redirect, usePathname, useRouter, getPathname } =
+  createNavigation(routing);
+```
+
+## API
+
+- **From `tanstack-start-intl`**: `NextIntlClientProvider`, `createNavigation`, `hasLocale`, `useTranslations`, `useFormatter`, `useLocale`, `useMessages`, `useNow`, `useTimeZone`
+- **From `tanstack-start-intl/server`**: `getRequestConfig`, `setRequestLocale`, `getTranslations`, `getLocale`, `getMessages`, `getFormatter`, `getTimeZone`, `getNow`
+- **From `tanstack-start-intl/routing`**: `defineRouting`, routing types
+
+## Notes
+
+- Locale is **only** taken from `setRequestLocale(locale)` in your locale layout. There is no header-based detection; call `setRequestLocale` before any server API use.
+- Configure the alias `tanstack-start-intl/config` to your request file so server APIs can load messages and locale.

package/config.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This module is resolved at build time via your Vite/Start alias to your
+ * i18n request file (e.g. src/i18n/request.ts). The default export should
+ * be the result of getRequestConfig().
+ */
+declare module 'tanstack-start-intl/config' {
+  import type {
+    GetRequestConfigParams,
+    RequestConfig
+  } from 'tanstack-start-intl/server';
+  const getRequestConfig: (
+    params: GetRequestConfigParams
+  ) => RequestConfig | Promise<RequestConfig>;
+  export default getRequestConfig;
+}

package/dist/esm/development/config.js

@@ -0,0 +1,5 @@
+function getConfig() {
+  throw new Error("Could not find tanstack-start-intl config. Add a Vite/Start alias: 'tanstack-start-intl/config' -> './src/i18n/request' (or your request file).");
+}
+
+export { getConfig as default };

package/dist/esm/development/index.js

@@ -0,0 +1,113 @@
+import { IntlProvider } from 'use-intl/react';
+export { useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations } from 'use-intl/react';
+import { jsx } from 'react/jsx-runtime';
+import { useRouter, useLocation, Link, redirect } from '@tanstack/react-router';
+import { useMemo } from 'react';
+import { useLocale } from 'use-intl';
+import { u as unprefixPathname, g as getRoute, a as applyPathnamePrefix, b as getLocalePrefix } from './utils-UUs5JKte.js';
+export { hasLocale } from 'use-intl/core';
+
+function NextIntlClientProvider({
+  locale,
+  ...rest
+}) {
+  if (!locale) {
+    throw new Error('Missing `locale` prop on NextIntlClientProvider. Pass the locale from your layout (e.g. from getRequestConfig or route params).' );
+  }
+  return /*#__PURE__*/jsx(IntlProvider, {
+    locale: locale,
+    ...rest
+  });
+}
+
+/** Cookie config for locale persistence (framework-agnostic). */
+
+function receiveRoutingConfig(input) {
+  return {
+    ...input,
+    localePrefix: receiveLocalePrefixConfig(input.localePrefix),
+    localeCookie: receiveLocaleCookie(input.localeCookie),
+    localeDetection: input.localeDetection ?? true,
+    alternateLinks: input.alternateLinks ?? true
+  };
+}
+function receiveLocaleCookie(localeCookie) {
+  return localeCookie ?? true ? {
+    name: 'TANSTACK_LOCALE',
+    sameSite: 'lax',
+    ...(typeof localeCookie === 'object' && localeCookie)
+  } : false;
+}
+function receiveLocalePrefixConfig(localePrefix) {
+  return typeof localePrefix === 'object' ? localePrefix : {
+    mode: localePrefix || 'always'
+  };
+}
+
+function createNavigation(routing) {
+  const config = receiveRoutingConfig(routing || {});
+  function usePathname() {
+    const location = useLocation();
+    const pathname = location.pathname || '/';
+    const locale = useLocale();
+    const prefix = getLocalePrefix(locale, config.localePrefix);
+    const unprefixed = prefix ? unprefixPathname(pathname, prefix) : pathname;
+    if (!config.pathnames) return unprefixed;
+    return getRoute(locale, unprefixed, config.pathnames);
+  }
+  function getPathname(pathnameOrPathnames, locale, opts) {
+    const pathname = typeof pathnameOrPathnames === 'string' ? pathnameOrPathnames : pathnameOrPathnames[locale] || pathnameOrPathnames[config.defaultLocale] || '/';
+    return applyPathnamePrefix(pathname, locale, config, opts?.force);
+  }
+  function Link$1({
+    href,
+    locale: localeProp,
+    ...rest
+  }) {
+    const currentLocale = useLocale();
+    const locale = localeProp ?? currentLocale;
+    const to = useMemo(() => {
+      const pathname = typeof href === 'object' ? href.pathname : href;
+      const params = typeof href === 'object' ? href.params : undefined;
+      const pathnames = config.pathnames;
+      const pathnameConfig = pathnames ? pathnames[pathname] : pathname;
+      let resolvedPathname;
+      if (pathnameConfig === undefined || pathnameConfig === null) {
+        resolvedPathname = pathname;
+      } else if (typeof pathnameConfig === 'string') {
+        resolvedPathname = pathnameConfig;
+      } else {
+        const localizedPathnames = pathnameConfig;
+        resolvedPathname = localizedPathnames[locale] ?? localizedPathnames[config.defaultLocale] ?? pathname;
+      }
+      const localized = getPathname(resolvedPathname, locale);
+      if (params && Object.keys(params).length > 0) {
+        return {
+          pathname: localized,
+          search: params
+        };
+      }
+      return localized;
+    }, [href, locale]);
+    return /*#__PURE__*/jsx(Link, {
+      to: to,
+      ...rest
+    });
+  }
+  function redirect$1(pathname, locale) {
+    const loc = locale ?? config.defaultLocale;
+    const target = getPathname(pathname, loc);
+    throw redirect({
+      to: target
+    });
+  }
+  return {
+    Link: Link$1,
+    redirect: redirect$1,
+    usePathname,
+    useRouter,
+    getPathname
+  };
+}
+
+export { NextIntlClientProvider, createNavigation };

package/dist/esm/development/routing.js

@@ -0,0 +1,25 @@
+function defineRouting(config) {
+  if (config.domains) {
+    validateUniqueLocalesPerDomain(config.domains);
+  }
+  return config;
+}
+function validateUniqueLocalesPerDomain(domains) {
+  const domainsByLocale = new Map();
+  for (const {
+    domain,
+    locales
+  } of domains) {
+    for (const locale of locales) {
+      const localeDomains = domainsByLocale.get(locale) || new Set();
+      localeDomains.add(domain);
+      domainsByLocale.set(locale, localeDomains);
+    }
+  }
+  const duplicateLocaleMessages = Array.from(domainsByLocale.entries()).filter(([, localeDomains]) => localeDomains.size > 1).map(([locale, localeDomains]) => `- "${locale}" is used by: ${Array.from(localeDomains).join(', ')}`);
+  if (duplicateLocaleMessages.length > 0) {
+    console.warn('Locales are expected to be unique per domain, but found overlap:\n' + duplicateLocaleMessages.join('\n'));
+  }
+}
+
+export { defineRouting };

package/dist/esm/development/server.js

@@ -0,0 +1,180 @@
+import { cache } from 'react';
+import { initializeConfig, _createIntlFormatters, _createCache, createTranslator, createFormatter } from 'use-intl/core';
+import { i as isPromise } from './utils-UUs5JKte.js';
+import getRuntimeConfig from 'tanstack-start-intl/config';
+
+/**
+ * Use in your i18n request file (e.g. `src/i18n/request.ts`) to create
+ * the configuration for the current request. Configure your Vite/Start
+ * alias: `'tanstack-start-intl/config'` -> `'./src/i18n/request'`.
+ */
+function getRequestConfig(createRequestConfig) {
+  return createRequestConfig;
+}
+
+function getCacheImpl() {
+  const value = {
+    locale: undefined
+  };
+  return value;
+}
+const getCache$1 = cache(getCacheImpl);
+function getCachedRequestLocale() {
+  return getCache$1().locale;
+}
+function setCachedRequestLocale(locale) {
+  getCache$1().locale = locale;
+}
+
+/**
+ * Returns the request locale. In TanStack Start, locale must be set via
+ * `setRequestLocale(locale)` in your locale layout (e.g. in `$locale.tsx`)
+ * before any server APIs are used.
+ */
+async function getRequestLocale() {
+  return getCachedRequestLocale();
+}
+
+function validateLocale(locale) {
+  try {
+    const constructed = new Intl.Locale(locale);
+    if (!constructed.language) {
+      throw new Error('Language is required');
+    }
+  } catch {
+    console.error(`An invalid locale was provided: "${locale}". Please use a valid Unicode locale identifier (e.g. "en-US").`);
+  }
+}
+
+function getDefaultTimeZoneImpl() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+const getDefaultTimeZone = cache(getDefaultTimeZoneImpl);
+async function receiveRuntimeConfigImpl(getConfig, localeOverride) {
+  if (typeof getConfig !== 'function') {
+    throw new Error(`Invalid i18n request configuration.
+
+Please:
+1. Add a Vite/Start alias: 'tanstack-start-intl/config' -> './src/i18n/request' (or your request file path).
+2. Ensure your i18n request file has a default export that calls getRequestConfig().
+
+See: https://github.com/amannn/next-intl#tanstack-start`);
+  }
+  const params = {
+    locale: localeOverride,
+    get requestLocale() {
+      return localeOverride ? Promise.resolve(localeOverride) : getRequestLocale();
+    }
+  };
+  let result = getConfig(params);
+  if (isPromise(result)) {
+    result = await result;
+  }
+  if (!result.locale) {
+    throw new Error('No locale was returned from `getRequestConfig`. Ensure your i18n request file returns { locale, messages, ... }.');
+  }
+  {
+    validateLocale(result.locale);
+  }
+  return result;
+}
+const receiveRuntimeConfig = cache(receiveRuntimeConfigImpl);
+const getFormatters = cache(_createIntlFormatters);
+const getCache = cache(_createCache);
+async function getConfigImpl(localeOverride) {
+  const runtimeConfig = await receiveRuntimeConfig(getRuntimeConfig, localeOverride);
+  return {
+    ...initializeConfig(runtimeConfig),
+    _formatters: getFormatters(getCache()),
+    timeZone: runtimeConfig.timeZone || getDefaultTimeZone()
+  };
+}
+const getConfig = cache(getConfigImpl);
+
+function getServerTranslatorImpl(config, namespace) {
+  return createTranslator({
+    ...config,
+    namespace
+  });
+}
+var getServerTranslator = cache(getServerTranslatorImpl);
+
+async function getTranslations(namespaceOrOpts) {
+  let namespace;
+  let locale;
+  if (typeof namespaceOrOpts === 'string') {
+    namespace = namespaceOrOpts;
+  } else if (namespaceOrOpts) {
+    locale = namespaceOrOpts.locale;
+    namespace = namespaceOrOpts.namespace;
+  }
+  const config = await getConfig(locale);
+  return getServerTranslator(config, namespace);
+}
+var getTranslations_default = cache(getTranslations);
+
+async function getLocaleCachedImpl() {
+  const config = await getConfig();
+  return config.locale;
+}
+const getLocaleCached = cache(getLocaleCachedImpl);
+
+function getMessagesFromConfig(config) {
+  if (!config.messages) {
+    throw new Error('No messages found. Have you configured them in getRequestConfig?');
+  }
+  return config.messages;
+}
+async function getMessagesCachedImpl(locale) {
+  const config = await getConfig(locale);
+  return getMessagesFromConfig(config);
+}
+const getMessagesCached = cache(getMessagesCachedImpl);
+async function getMessages(opts) {
+  return getMessagesCached(opts?.locale);
+}
+
+function defaultNow() {
+  return new Date();
+}
+const getDefaultNow = cache(defaultNow);
+
+function getFormatterCachedImpl$1(config) {
+  return createFormatter({
+    ...config,
+    get now() {
+      return config.now ?? getDefaultNow();
+    }
+  });
+}
+const getFormatterCached$1 = cache(getFormatterCachedImpl$1);
+
+async function getFormatterCachedImpl(locale) {
+  const config = await getConfig(locale);
+  return getFormatterCached$1(config);
+}
+const getFormatterCached = cache(getFormatterCachedImpl);
+async function getFormatter(opts) {
+  return getFormatterCached(opts?.locale);
+}
+
+async function getTimeZoneCachedImpl(locale) {
+  const config = await getConfig(locale);
+  return config.timeZone;
+}
+const getTimeZoneCached = cache(getTimeZoneCachedImpl);
+async function getTimeZone(opts) {
+  return getTimeZoneCached(opts?.locale);
+}
+
+async function getConfigNowImpl(locale) {
+  const config = await getConfig(locale);
+  return config.now;
+}
+const getConfigNow = cache(getConfigNowImpl);
+
+async function getNow(opts) {
+  return (await getConfigNow(opts?.locale)) ?? getDefaultNow();
+}
+
+export { getFormatter, getLocaleCached as getLocale, getMessages, getMessagesFromConfig, getNow, getRequestConfig, getTimeZone, getTranslations_default as getTranslations, setCachedRequestLocale as setRequestLocale };

package/dist/esm/development/utils-UUs5JKte.js

@@ -0,0 +1,136 @@
+function isRelativeHref(href) {
+  const pathname = typeof href === 'object' ? href.pathname : href;
+  return typeof pathname === 'string' && !pathname.startsWith('/');
+}
+function isLocalHref(href) {
+  if (typeof href === 'object') {
+    return true;
+  }
+  const hasProtocol = /^[a-z]+:/i.test(href);
+  return !hasProtocol;
+}
+function isLocalizableHref(href) {
+  return isLocalHref(href) && !isRelativeHref(href);
+}
+function unprefixPathname(pathname, prefix) {
+  return pathname.replace(new RegExp(`^${prefix}`), '') || '/';
+}
+function prefixPathname(prefix, pathname) {
+  let localizedHref = prefix;
+  if (/^\/(\?.*)?$/.test(pathname)) {
+    pathname = pathname.slice(1);
+  }
+  localizedHref += pathname;
+  return localizedHref;
+}
+function getLocalizedTemplate(pathnameConfig, locale, internalTemplate) {
+  return typeof pathnameConfig === 'string' ? pathnameConfig : pathnameConfig[locale] || internalTemplate;
+}
+function normalizeTrailingSlash(pathname, trailingSlash = false) {
+  const [path, ...hashParts] = pathname.split('#');
+  const hash = hashParts.join('#');
+  let normalizedPath = path;
+  if (normalizedPath !== '/') {
+    const pathnameEndsWithSlash = normalizedPath.endsWith('/');
+    if (trailingSlash && !pathnameEndsWithSlash) {
+      normalizedPath += '/';
+    } else if (!trailingSlash && pathnameEndsWithSlash) {
+      normalizedPath = normalizedPath.slice(0, -1);
+    }
+  }
+  if (hash) {
+    normalizedPath += '#' + hash;
+  }
+  return normalizedPath;
+}
+function matchesPathname(template, pathname) {
+  const normalizedTemplate = normalizeTrailingSlash(template);
+  const normalizedPathname = normalizeTrailingSlash(pathname);
+  const regex = templateToRegex(normalizedTemplate);
+  return regex.test(normalizedPathname);
+}
+function getLocalePrefix(locale, localePrefix) {
+  return localePrefix.mode !== 'never' && localePrefix.prefixes?.[locale] || getLocaleAsPrefix(locale);
+}
+function getLocaleAsPrefix(locale) {
+  return '/' + locale;
+}
+function templateToRegex(template) {
+  const regexPattern = template.replace(/\/\[\[(\.\.\.[^\]]+)\]\]/g, '(?:/(.*))?').replace(/\[\[(\.\.\.[^\]]+)\]\]/g, '(?:/(.*))?').replace(/\[(\.\.\.[^\]]+)\]/g, '(.+)').replace(/\[([^\]]+)\]/g, '([^/]+)');
+  return new RegExp(`^${regexPattern}$`);
+}
+function isOptionalCatchAllSegment(pathname) {
+  return pathname.includes('[[...');
+}
+function isCatchAllSegment(pathname) {
+  return pathname.includes('[...');
+}
+function isDynamicSegment(pathname) {
+  return pathname.includes('[');
+}
+function comparePathnamePairs(a, b) {
+  const pathA = a.split('/');
+  const pathB = b.split('/');
+  const maxLength = Math.max(pathA.length, pathB.length);
+  for (let i = 0; i < maxLength; i++) {
+    const segmentA = pathA[i];
+    const segmentB = pathB[i];
+    if (!segmentA && segmentB) return -1;
+    if (segmentA && !segmentB) return 1;
+    if (!segmentA && !segmentB) continue;
+    if (!isDynamicSegment(segmentA) && isDynamicSegment(segmentB)) return -1;
+    if (isDynamicSegment(segmentA) && !isDynamicSegment(segmentB)) return 1;
+    if (!isCatchAllSegment(segmentA) && isCatchAllSegment(segmentB)) return -1;
+    if (isCatchAllSegment(segmentA) && !isCatchAllSegment(segmentB)) return 1;
+    if (!isOptionalCatchAllSegment(segmentA) && isOptionalCatchAllSegment(segmentB)) {
+      return -1;
+    }
+    if (isOptionalCatchAllSegment(segmentA) && !isOptionalCatchAllSegment(segmentB)) {
+      return 1;
+    }
+    if (segmentA === segmentB) continue;
+  }
+  return 0;
+}
+function getSortedPathnames(pathnames) {
+  return pathnames.sort(comparePathnamePairs);
+}
+function isPromise(value) {
+  return typeof value.then === 'function';
+}
+function getRoute(locale, pathname, pathnames) {
+  const sortedPathnames = getSortedPathnames(Object.keys(pathnames));
+  const decoded = decodeURI(pathname);
+  for (const internalPathname of sortedPathnames) {
+    const localizedPathnamesOrPathname = pathnames[internalPathname];
+    if (typeof localizedPathnamesOrPathname === 'string') {
+      const localizedPathname = localizedPathnamesOrPathname;
+      if (matchesPathname(localizedPathname, decoded)) {
+        return internalPathname;
+      }
+    } else {
+      if (matchesPathname(getLocalizedTemplate(localizedPathnamesOrPathname, locale, internalPathname), decoded)) {
+        return internalPathname;
+      }
+    }
+  }
+  return pathname;
+}
+function applyPathnamePrefix(pathname, locale, routing, force) {
+  const {
+    mode
+  } = routing.localePrefix;
+  let shouldPrefix;
+  if (force !== undefined) {
+    shouldPrefix = force;
+  } else if (isLocalizableHref(pathname)) {
+    if (mode === 'always') {
+      shouldPrefix = true;
+    } else if (mode === 'as-needed') {
+      shouldPrefix = routing.domains ? !routing.domains.some(cur => cur.defaultLocale === locale) : locale !== routing.defaultLocale;
+    }
+  }
+  return shouldPrefix ? prefixPathname(getLocalePrefix(locale, routing.localePrefix), pathname) : pathname;
+}
+
+export { applyPathnamePrefix as a, getLocalePrefix as b, getRoute as g, isPromise as i, unprefixPathname as u };

package/dist/esm/production/config.js

@@ -0,0 +1 @@
+function t(){throw new Error("Could not find tanstack-start-intl config. Add a Vite/Start alias: 'tanstack-start-intl/config' -> './src/i18n/request' (or your request file).")}export{t as default};

package/dist/esm/production/index.js

@@ -0,0 +1 @@
+import{IntlProvider as e}from"use-intl/react";export{useFormatter,useLocale,useMessages,useNow,useTimeZone,useTranslations}from"use-intl/react";import{jsx as t}from"react/jsx-runtime";import{useRouter as o,useLocation as a,Link as r,redirect as n}from"@tanstack/react-router";import{useMemo as s}from"react";import{useLocale as c}from"use-intl";import{u as l,g as i,a as u,b as f}from"./utils-Y3ZAPIbE.js";export{hasLocale}from"use-intl/core";function m({locale:o,...a}){if(!o)throw new Error(void 0);return t(e,{locale:o,...a})}function p(e){const m=(p=e||{},{...p,localePrefix:(L=p.localePrefix,"object"==typeof L?L:{mode:L||"always"}),localeCookie:(h=p.localeCookie,!!(h??1)&&{name:"TANSTACK_LOCALE",sameSite:"lax",..."object"==typeof h&&h}),localeDetection:p.localeDetection??!0,alternateLinks:p.alternateLinks??!0});var p,h,L;function x(e,t,o){const a="string"==typeof e?e:e[t]||e[m.defaultLocale]||"/";return u(a,t,m,o?.force)}return{Link:function({href:e,locale:o,...a}){const n=c(),l=o??n,i=s((()=>{const t="object"==typeof e?e.pathname:e,o="object"==typeof e?e.params:void 0,a=m.pathnames,r=a?a[t]:t;let n;if(null==r)n=t;else if("string"==typeof r)n=r;else{const e=r;n=e[l]??e[m.defaultLocale]??t}const s=x(n,l);return o&&Object.keys(o).length>0?{pathname:s,search:o}:s}),[e,l]);return t(r,{to:i,...a})},redirect:function(e,t){const o=x(e,t??m.defaultLocale);throw n({to:o})},usePathname:function(){const e=a().pathname||"/",t=c(),o=f(t,m.localePrefix),r=o?l(e,o):e;return m.pathnames?i(t,r,m.pathnames):r},useRouter:o,getPathname:x}}export{m as NextIntlClientProvider,p as createNavigation};

package/dist/esm/production/routing.js

@@ -0,0 +1 @@
+function n(n){return n}export{n as defineRouting};

package/dist/esm/production/server.js

@@ -0,0 +1 @@
+import{cache as n}from"react";import{initializeConfig as t,_createIntlFormatters as e,_createCache as o,createTranslator as r,createFormatter as a}from"use-intl/core";import{i as c}from"./utils-Y3ZAPIbE.js";import s from"tanstack-start-intl/config";function i(n){return n}const u=n((function(){return{locale:void 0}}));function l(n){u().locale=n}async function f(){return u().locale}const m=n((function(){return Intl.DateTimeFormat().resolvedOptions().timeZone}));const w=n((async function(n,t){let e=n({locale:t,get requestLocale(){return t?Promise.resolve(t):f()}});if(c(e)&&(e=await e),!e.locale)throw new Error("No locale was returned from `getRequestConfig`. Ensure your i18n request file returns { locale, messages, ... }.");return e})),y=n(e),g=n(o);const p=n((async function(n){const e=await w(s,n);return{...t(e),_formatters:y(g()),timeZone:e.timeZone||m()}}));var v=n((function(n,t){return r({...n,namespace:t})}));var d=n((async function(n){let t,e;"string"==typeof n?t=n:n&&(e=n.locale,t=n.namespace);const o=await p(e);return v(o,t)}));const q=n((async function(){return(await p()).locale}));function Z(n){if(!n.messages)throw new Error("No messages found. Have you configured them in getRequestConfig?");return n.messages}const h=n((async function(n){return Z(await p(n))}));async function E(n){return h(n?.locale)}const L=n((function(){return new Date}));const R=n((function(n){return a({...n,get now(){return n.now??L()}})}));const C=n((async function(n){const t=await p(n);return R(t)}));async function D(n){return C(n?.locale)}const N=n((async function(n){return(await p(n)).timeZone}));async function T(n){return N(n?.locale)}const j=n((async function(n){return(await p(n)).now}));async function k(n){return await j(n?.locale)??L()}export{D as getFormatter,q as getLocale,E as getMessages,Z as getMessagesFromConfig,k as getNow,i as getRequestConfig,T as getTimeZone,d as getTranslations,l as setRequestLocale};

package/dist/esm/production/utils-Y3ZAPIbE.js

@@ -0,0 +1 @@
+function t(t,n){return t.replace(new RegExp(`^${n}`),"")||"/"}function n(t,n,e){return"string"==typeof t?t:t[n]||e}function e(t,n=!1){const[e,...r]=t.split("#"),o=r.join("#");let i=e;if("/"!==i){const t=i.endsWith("/");n&&!t?i+="/":!n&&t&&(i=i.slice(0,-1))}return o&&(i+="#"+o),i}function r(t,n){const r=e(t),o=e(n),i=function(t){const n=t.replace(/\/\[\[(\.\.\.[^\]]+)\]\]/g,"(?:/(.*))?").replace(/\[\[(\.\.\.[^\]]+)\]\]/g,"(?:/(.*))?").replace(/\[(\.\.\.[^\]]+)\]/g,"(.+)").replace(/\[([^\]]+)\]/g,"([^/]+)");return new RegExp(`^${n}$`)}(r);return i.test(o)}function o(t,n){return"never"!==n.mode&&n.prefixes?.[t]||function(t){return"/"+t}(t)}function i(t){return t.includes("[[...")}function u(t){return t.includes("[...")}function c(t){return t.includes("[")}function f(t,n){const e=t.split("/"),r=n.split("/"),o=Math.max(e.length,r.length);for(let t=0;t<o;t++){const n=e[t],o=r[t];if(!n&&o)return-1;if(n&&!o)return 1;if(n||o){if(!c(n)&&c(o))return-1;if(c(n)&&!c(o))return 1;if(!u(n)&&u(o))return-1;if(u(n)&&!u(o))return 1;if(!i(n)&&i(o))return-1;if(i(n)&&!i(o))return 1}}return 0}function s(t){return"function"==typeof t.then}function a(t,e,o){const i=function(t){return t.sort(f)}(Object.keys(o)),u=decodeURI(e);for(const e of i){const i=o[e];if("string"==typeof i){if(r(i,u))return e}else if(r(n(i,t,e),u))return e}return e}function l(t,n,e,r){const{mode:i}=e.localePrefix;let u;var c;return void 0!==r?u=r:function(t){return"object"==typeof t||!/^[a-z]+:/i.test(t)}(c=t)&&!function(t){const n="object"==typeof t?t.pathname:t;return"string"==typeof n&&!n.startsWith("/")}(c)&&("always"===i?u=!0:"as-needed"===i&&(u=e.domains?!e.domains.some((t=>t.defaultLocale===n)):n!==e.defaultLocale)),u?function(t,n){let e=t;return/^\/(\?.*)?$/.test(n)&&(n=n.slice(1)),e+=n,e}(o(n,e.localePrefix),t):t}export{l as a,o as b,a as g,s as i,t as u};

package/dist/types/src/NextIntlClientProvider.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentProps } from 'react';
+import type { Locale } from 'use-intl';
+import { IntlProvider } from 'use-intl/react';
+type Props = Omit<ComponentProps<typeof IntlProvider>, 'locale'> & {
+    /** Pass explicitly when rendering in layout; required when not from a Server Component that set request locale. */
+    locale?: Locale;
+};
+export default function NextIntlClientProvider({ locale, ...rest }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/src/config.d.ts

@@ -0,0 +1 @@
+export default function getConfig(): void;

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

@@ -0,0 +1,4 @@
+export { default as NextIntlClientProvider } from './NextIntlClientProvider.js';
+export { default as createNavigation } from './navigation/createNavigation.js';
+export { hasLocale } from 'use-intl/core';
+export { useTranslations, useFormatter, useLocale, useMessages, useNow, useTimeZone } from 'use-intl/react';

package/dist/types/src/navigation/createNavigation.d.ts

@@ -0,0 +1,20 @@
+import { Link as RouterLink, useRouter } from '@tanstack/react-router';
+import type { ComponentProps } from 'react';
+import type { Locale } from 'use-intl';
+import type { RoutingConfigLocalizedNavigation, RoutingConfigSharedNavigation } from '../routing/config.js';
+import type { DomainsConfig, LocalePrefixMode, Locales, Pathnames } from '../routing/types.js';
+export default function createNavigation<const AppLocales extends Locales, const AppLocalePrefixMode extends LocalePrefixMode = 'always', const AppPathnames extends Pathnames<AppLocales> = never, const AppDomains extends DomainsConfig<AppLocales> = never>(routing?: [AppPathnames] extends [never] ? RoutingConfigSharedNavigation<AppLocales, AppLocalePrefixMode, AppDomains> | undefined : RoutingConfigLocalizedNavigation<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>): {
+    Link: <Pathname extends keyof AppPathnames = never>({ href, locale: localeProp, ...rest }: Omit<ComponentProps<typeof RouterLink>, "to"> & {
+        href: [AppPathnames] extends [never] ? string : Pathname | {
+            pathname: Pathname;
+            params?: Record<string, string>;
+        };
+        locale?: Locale;
+    }) => import("react/jsx-runtime").JSX.Element;
+    redirect: (pathname: string, locale?: Locale) => void;
+    usePathname: () => [AppPathnames] extends [never] ? string : keyof AppPathnames;
+    useRouter: typeof useRouter;
+    getPathname: (pathnameOrPathnames: string | Record<string, string>, locale: Locale, opts?: {
+        force?: boolean;
+    }) => string;
+};

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

@@ -0,0 +1,50 @@
+import type { DomainsConfig, LocalePrefix, LocalePrefixConfigVerbose, LocalePrefixMode, Locales, Pathnames } from './types.js';
+/** Cookie config for locale persistence (framework-agnostic). */
+export type LocaleCookieAttributes = {
+    maxAge?: number;
+    domain?: string;
+    path?: string;
+    sameSite?: 'lax' | 'strict' | 'none';
+    secure?: boolean;
+    name?: string;
+};
+export type RoutingConfig<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppPathnames extends Pathnames<AppLocales> | undefined, AppDomains extends DomainsConfig<AppLocales> | undefined> = {
+    locales: AppLocales;
+    defaultLocale: AppLocales[number];
+    localePrefix?: LocalePrefix<AppLocales, AppLocalePrefixMode>;
+    domains?: AppDomains;
+    localeCookie?: boolean | LocaleCookieAttributes;
+    alternateLinks?: boolean;
+    localeDetection?: boolean;
+} & ([AppPathnames] extends [never] ? {} : {
+    pathnames: AppPathnames;
+});
+export type RoutingConfigSharedNavigation<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppDomains extends DomainsConfig<AppLocales> = never> = Omit<RoutingConfig<AppLocales, AppLocalePrefixMode, never, AppDomains>, 'defaultLocale' | 'locales' | 'pathnames'> & Partial<Pick<RoutingConfig<AppLocales, never, never, AppDomains>, 'defaultLocale' | 'locales'>>;
+export type RoutingConfigLocalizedNavigation<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppPathnames extends Pathnames<AppLocales>, AppDomains extends DomainsConfig<AppLocales> = never> = Omit<RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>, 'defaultLocale' | 'pathnames'> & Partial<Pick<RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>, 'defaultLocale'>> & {
+    pathnames: AppPathnames;
+};
+export type InitializedLocaleCookieConfig = false | {
+    name: string;
+    sameSite: 'lax' | 'strict' | 'none';
+    [key: string]: unknown;
+};
+export type ResolvedRoutingConfig<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppPathnames extends Pathnames<AppLocales> | undefined, AppDomains extends DomainsConfig<AppLocales> | undefined> = Omit<RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>, 'localePrefix' | 'localeCookie' | 'alternateLinks' | 'localeDetection'> & {
+    localePrefix: LocalePrefixConfigVerbose<AppLocales, AppLocalePrefixMode>;
+    localeCookie: InitializedLocaleCookieConfig;
+    alternateLinks: boolean;
+    localeDetection: boolean;
+};
+export declare function receiveRoutingConfig<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppPathnames extends Pathnames<AppLocales> | undefined, AppDomains extends DomainsConfig<AppLocales> | undefined, Config extends Partial<RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>>>(input: Config): Omit<Config, "localePrefix" | "localeCookie" | "alternateLinks" | "localeDetection"> & {
+    localePrefix: {
+        mode: "never";
+    } | {
+        mode: "always";
+        prefixes?: Partial<Record<AppLocales[number], string>> | undefined;
+    } | {
+        mode: "as-needed";
+        prefixes?: Partial<Record<AppLocales[number], string>> | undefined;
+    };
+    localeCookie: InitializedLocaleCookieConfig;
+    localeDetection: boolean | NonNullable<RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>["localeDetection"]>;
+    alternateLinks: boolean | NonNullable<RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>["alternateLinks"]>;
+};

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

@@ -0,0 +1,3 @@
+import type { RoutingConfig } from './config.js';
+import type { DomainsConfig, LocalePrefixMode, Locales, Pathnames } from './types.js';
+export default function defineRouting<const AppLocales extends Locales, const AppLocalePrefixMode extends LocalePrefixMode = 'always', const AppPathnames extends Pathnames<AppLocales> = never, const AppDomains extends DomainsConfig<AppLocales> = never>(config: RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>): RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>;

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

@@ -0,0 +1,3 @@
+export type { Pathnames, LocalePrefix, DomainsConfig, LocalePrefixMode } from './types.js';
+export { default as defineRouting } from './defineRouting.js';
+export type { RoutingConfig } from './config.js';

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

@@ -0,0 +1,22 @@
+export type Locales = ReadonlyArray<string>;
+export type LocalePrefixMode = 'always' | 'as-needed' | 'never';
+type Pathname = string;
+export type LocalePrefixes<AppLocales extends Locales> = Partial<Record<AppLocales[number], Pathname>>;
+export type LocalePrefixConfigVerbose<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode> = AppLocalePrefixMode extends 'always' ? {
+    mode: 'always';
+    prefixes?: LocalePrefixes<AppLocales>;
+} : AppLocalePrefixMode extends 'as-needed' ? {
+    mode: 'as-needed';
+    prefixes?: LocalePrefixes<AppLocales>;
+} : {
+    mode: 'never';
+};
+export type LocalePrefix<AppLocales extends Locales = [], AppLocalePrefixMode extends LocalePrefixMode = 'always'> = AppLocalePrefixMode | LocalePrefixConfigVerbose<AppLocales, AppLocalePrefixMode>;
+export type Pathnames<AppLocales extends Locales> = Record<Pathname, Partial<Record<AppLocales[number], Pathname>> | Pathname>;
+export type DomainConfig<AppLocales extends Locales> = {
+    defaultLocale: AppLocales[number];
+    domain: string;
+    locales: Array<AppLocales[number]>;
+};
+export type DomainsConfig<AppLocales extends Locales> = Array<DomainConfig<AppLocales>>;
+export {};

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

@@ -0,0 +1,3 @@
+export type { Pathnames, LocalePrefix, DomainsConfig, LocalePrefixMode } from './routing/types.js';
+export { default as defineRouting } from './routing/defineRouting.js';
+export type { RoutingConfig } from './routing/config.js';

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

@@ -0,0 +1,7 @@
+import type { Locale } from 'use-intl';
+/**
+ * Returns the request locale. In TanStack Start, locale must be set via
+ * `setRequestLocale(locale)` in your locale layout (e.g. in `$locale.tsx`)
+ * before any server APIs are used.
+ */
+export declare function getRequestLocale(): Promise<Locale | undefined>;

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

@@ -0,0 +1,3 @@
+import type { Locale } from 'use-intl';
+export declare function getCachedRequestLocale(): string | undefined;
+export declare function setCachedRequestLocale(locale: Locale): void;

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

@@ -0,0 +1,3 @@
+import type { GetRequestConfigParams, RequestConfig } from './getRequestConfig.js';
+declare const _default: (params: GetRequestConfigParams) => RequestConfig | Promise<RequestConfig>;
+export default _default;

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

@@ -0,0 +1,13 @@
+import { type IntlConfig, type Locale, _createIntlFormatters } from 'use-intl/core';
+declare function getConfigImpl(localeOverride?: Locale): Promise<{
+    locale: IntlConfig['locale'];
+    formats?: NonNullable<IntlConfig['formats']>;
+    timeZone: NonNullable<IntlConfig['timeZone']>;
+    onError: NonNullable<IntlConfig['onError']>;
+    getMessageFallback: NonNullable<IntlConfig['getMessageFallback']>;
+    messages?: NonNullable<IntlConfig['messages']>;
+    now?: NonNullable<IntlConfig['now']>;
+    _formatters: ReturnType<typeof _createIntlFormatters>;
+}>;
+declare const getConfig: typeof getConfigImpl;
+export default getConfig;

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

@@ -0,0 +1,4 @@
+import type { Locale } from 'use-intl';
+declare function getConfigNowImpl(locale?: Locale): Promise<Date | undefined>;
+declare const getConfigNow: typeof getConfigNowImpl;
+export default getConfigNow;

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

@@ -0,0 +1,3 @@
+declare function defaultNow(): Date;
+declare const getDefaultNow: typeof defaultNow;
+export default getDefaultNow;

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

@@ -0,0 +1,4 @@
+import type { Locale, createFormatter } from 'use-intl/core';
+export default function getFormatter(opts?: {
+    locale?: Locale;
+}): Promise<ReturnType<typeof createFormatter>>;

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

@@ -0,0 +1,4 @@
+import type { Locale } from 'use-intl';
+declare function getLocaleCachedImpl(): Promise<Locale>;
+declare const getLocaleCached: typeof getLocaleCachedImpl;
+export default getLocaleCached;

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

@@ -0,0 +1,6 @@
+import type { Locale, useMessages as useMessagesType } from 'use-intl';
+import getConfig from './getConfig.js';
+export declare function getMessagesFromConfig(config: Awaited<ReturnType<typeof getConfig>>): ReturnType<typeof useMessagesType>;
+export default function getMessages(opts?: {
+    locale?: Locale;
+}): Promise<ReturnType<typeof useMessagesType>>;

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

@@ -0,0 +1,4 @@
+import type { Locale } from 'use-intl';
+export default function getNow(opts?: {
+    locale?: Locale;
+}): Promise<Date>;

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

@@ -0,0 +1,18 @@
+import type { IntlConfig, Locale } from 'use-intl/core';
+export type RequestConfig = Omit<IntlConfig, 'locale'> & {
+    locale: IntlConfig['locale'];
+};
+export type GetRequestConfigParams = {
+    locale?: Locale;
+    /**
+     * The locale from the current route (e.g. `$locale` param).
+     * Set via `setRequestLocale(locale)` in your locale layout.
+     */
+    requestLocale: Promise<string | undefined>;
+};
+/**
+ * Use in your i18n request file (e.g. `src/i18n/request.ts`) to create
+ * the configuration for the current request. Configure your Vite/Start
+ * alias: `'tanstack-start-intl/config'` -> `'./src/i18n/request'`.
+ */
+export default function getRequestConfig(createRequestConfig: (params: GetRequestConfigParams) => RequestConfig | Promise<RequestConfig>): (params: GetRequestConfigParams) => RequestConfig | Promise<RequestConfig>;

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

@@ -0,0 +1,25 @@
+import { createFormatter } from 'use-intl/core';
+declare function getFormatterCachedImpl(config: Parameters<typeof createFormatter>[0]): {
+    dateTime: {
+        (value: Date | number, options?: import("use-intl/core").DateTimeFormatOptions): string;
+        (value: Date | number, format?: import("node_modules/use-intl/dist/types/core/AppConfig.js").FormatNames["dateTime"], options?: import("use-intl/core").DateTimeFormatOptions): string;
+    };
+    number: {
+        (value: number | bigint, options?: import("use-intl/core").NumberFormatOptions): string;
+        (value: number | bigint, format?: import("node_modules/use-intl/dist/types/core/AppConfig.js").FormatNames["number"], options?: import("use-intl/core").NumberFormatOptions): string;
+    };
+    relativeTime: {
+        (date: number | Date, now?: import("use-intl/core").RelativeTimeFormatOptions["now"]): string;
+        (date: number | Date, options?: import("use-intl/core").RelativeTimeFormatOptions): string;
+    };
+    list: {
+        <Value extends string | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>>(value: Iterable<Value>, options?: Intl.ListFormatOptions): Value extends string ? string : Iterable<import("react").ReactElement>;
+        <Value extends string | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>>(value: Iterable<Value>, format?: import("node_modules/use-intl/dist/types/core/AppConfig.js").FormatNames["list"], options?: Intl.ListFormatOptions): Value extends string ? string : Iterable<import("react").ReactElement>;
+    };
+    dateTimeRange: {
+        (start: Date | number, end: Date | number, options?: import("use-intl/core").DateTimeFormatOptions): string;
+        (start: Date | number, end: Date | number, format?: import("node_modules/use-intl/dist/types/core/AppConfig.js").FormatNames["dateTime"], options?: import("use-intl/core").DateTimeFormatOptions): string;
+    };
+};
+declare const getFormatterCached: typeof getFormatterCachedImpl;
+export default getFormatterCached;

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

@@ -0,0 +1,4 @@
+import { type Messages, type NamespaceKeys, type NestedKeyOf, createTranslator } from 'use-intl/core';
+declare function getServerTranslatorImpl<NestedKey extends NamespaceKeys<Messages, NestedKeyOf<Messages>> = never>(config: Parameters<typeof createTranslator>[0], namespace?: NestedKey): ReturnType<typeof createTranslator<Messages, NestedKey>>;
+declare const _default: typeof getServerTranslatorImpl;
+export default _default;

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

@@ -0,0 +1,4 @@
+import type { Locale, Timezone } from 'use-intl';
+export default function getTimeZone(opts?: {
+    locale?: Locale;
+}): Promise<Timezone>;

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

@@ -0,0 +1,8 @@
+import type { Locale, Messages, NamespaceKeys, NestedKeyOf, createTranslator } from 'use-intl/core';
+declare function getTranslations<NestedKey extends NamespaceKeys<Messages, NestedKeyOf<Messages>> = never>(namespace?: NestedKey): Promise<ReturnType<typeof createTranslator<Messages, NestedKey>>>;
+declare function getTranslations<NestedKey extends NamespaceKeys<Messages, NestedKeyOf<Messages>> = never>(opts?: {
+    locale: Locale;
+    namespace?: NestedKey;
+}): Promise<ReturnType<typeof createTranslator<Messages, NestedKey>>>;
+declare const _default: typeof getTranslations;
+export default _default;

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

@@ -0,0 +1 @@
+export default function validateLocale(locale: string): void;

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

@@ -0,0 +1,9 @@
+export { default as getRequestConfig, type GetRequestConfigParams, type RequestConfig } from './server/getRequestConfig.js';
+export { setCachedRequestLocale as setRequestLocale } from './server/RequestLocaleCache.js';
+export { default as getTranslations } from './server/getTranslations.js';
+export { default as getLocale } from './server/getLocale.js';
+export { default as getMessages } from './server/getMessages.js';
+export { getMessagesFromConfig } from './server/getMessages.js';
+export { default as getFormatter } from './server/getFormatter.js';
+export { default as getTimeZone } from './server/getTimeZone.js';
+export { default as getNow } from './server/getNow.js';

package/dist/types/src/shared/utils.d.ts

@@ -0,0 +1,21 @@
+import type { ResolvedRoutingConfig } from '../routing/config.js';
+import type { DomainsConfig, LocalePrefixConfigVerbose, LocalePrefixMode, Locales, Pathnames } from '../routing/types.js';
+export type Href = string | {
+    pathname: string;
+    query?: Record<string, string>;
+};
+export declare function isLocalizableHref(href: Href): boolean;
+export declare function unprefixPathname(pathname: string, prefix: string): string;
+export declare function prefixPathname(prefix: string, pathname: string): string;
+export declare function hasPathnamePrefixed(prefix: string | undefined, pathname: string): boolean;
+export declare function getLocalizedTemplate<AppLocales extends Locales>(pathnameConfig: Pathnames<AppLocales>[keyof Pathnames<AppLocales>], locale: AppLocales[number], internalTemplate: string): string;
+export declare function normalizeTrailingSlash(pathname: string, trailingSlash?: boolean): string;
+export declare function matchesPathname(template: string, pathname: string): boolean;
+export declare function getLocalePrefix<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode>(locale: AppLocales[number], localePrefix: LocalePrefixConfigVerbose<AppLocales, AppLocalePrefixMode>): string;
+export declare function getLocaleAsPrefix(locale: string): string;
+export declare function templateToRegex(template: string): RegExp;
+export declare function getSortedPathnames(pathnames: Array<string>): string[];
+export declare function isPromise<Value>(value: Value | Promise<Value>): value is Promise<Value>;
+export declare function encodePathname(pathname: string): string;
+export declare function getRoute<AppLocales extends Locales>(locale: AppLocales[number], pathname: string, pathnames: Pathnames<AppLocales>): keyof Pathnames<AppLocales>;
+export declare function applyPathnamePrefix<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppPathnames extends Pathnames<AppLocales> | undefined, AppDomains extends DomainsConfig<AppLocales> | undefined>(pathname: string, locale: Locales[number], routing: Pick<ResolvedRoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>, 'localePrefix' | 'domains'> & Partial<Pick<ResolvedRoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>, 'defaultLocale'>>, force?: boolean): string;

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "tanstack-start-intl",
+  "version": "0.0.0-alpha.0",
+  "sideEffects": false,
+  "description": "Internationalization (i18n) for TanStack Start",
+  "license": "MIT",
+  "scripts": {
+    "build": "rm -rf dist && rollup -c",
+    "lint": "eslint src && tsc --noEmit",
+    "lint:prettier": "prettier src --check"
+  },
+  "type": "module",
+  "main": "./dist/esm/production/index.js",
+  "typings": "./dist/types/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/src/index.d.ts",
+      "development": "./dist/esm/development/index.js",
+      "default": "./dist/esm/production/index.js"
+    },
+    "./server": {
+      "types": "./dist/types/src/server.d.ts",
+      "development": "./dist/esm/development/server.js",
+      "default": "./dist/esm/production/server.js"
+    },
+    "./routing": {
+      "types": "./dist/types/src/routing.d.ts",
+      "development": "./dist/esm/development/routing.js",
+      "default": "./dist/esm/production/routing.js"
+    },
+    "./config": {
+      "types": "./dist/types/src/config.d.ts",
+      "development": "./dist/esm/development/config.js",
+      "default": "./dist/esm/production/config.js"
+    }
+  },
+  "files": ["dist", "config.d.ts", "routing.d.ts", "server.d.ts"],
+  "keywords": [
+    "react",
+    "intl",
+    "i18n",
+    "internationalization",
+    "localization",
+    "tanstack",
+    "tanstack-start"
+  ],
+  "dependencies": {
+    "use-intl": "workspace:^"
+  },
+  "peerDependencies": {
+    "@tanstack/react-router": ">=1.0.0",
+    "react": "^17.0.0 || ^18.0.0 || >=19.0.0-rc <19.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.5",
+    "@types/react": "^19.2.3",
+    "@types/react-dom": "^19.2.3",
+    "eslint": "9.11.1",
+    "eslint-config-molindo": "^8.0.0",
+    "prettier": "^3.3.3",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "rollup": "^4.18.0",
+    "tools": "workspace:^",
+    "typescript": "^5.5.3"
+  }
+}