@better-translate/tanstack-router 1.0.0

package/dist/navigation.js

@@ -0,0 +1,232 @@
+import {
+  isAbsoluteHref,
+  isPathnameInScope,
+  localizePathname,
+  parseRouteTemplate,
+  splitHrefString,
+  stripLocaleFromPathname
+} from "./chunk-LRCKROLX.js";
+
+// src/navigation.tsx
+import { createElement } from "react";
+function createNavigationFunctions({
+  Link: LinkComponent,
+  routing,
+  useLocation: useInjectedLocation,
+  useNavigate: useInjectedNavigate,
+  useParams: useInjectedParams,
+  useRouter: useInjectedRouter
+}) {
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  function getPathname({
+    href,
+    locale = routing.defaultLocale
+  }) {
+    return localizePathname(href, locale, routing);
+  }
+  const Link = ((rawProps) => {
+    const localizedOptions = getLocalizedOptions(
+      rawProps,
+      useInjectedLocation().pathname,
+      resolveActiveLocale(
+        useInjectedParams(),
+        routing,
+        parsedTemplate.localeParamName
+      ),
+      routing,
+      parsedTemplate.localeParamName,
+      parsedTemplate.localeSegment,
+      parsedTemplate.isRequired
+    );
+    return createElement(
+      LinkComponent,
+      localizedOptions
+    );
+  });
+  function usePathname() {
+    return stripLocaleFromPathname(useInjectedLocation().pathname, routing);
+  }
+  function useLocale() {
+    return resolveActiveLocale(
+      useInjectedParams(),
+      routing,
+      parsedTemplate.localeParamName
+    );
+  }
+  function useNavigate() {
+    const navigate = useInjectedNavigate();
+    const pathname = useInjectedLocation().pathname;
+    const activeLocale = useLocale();
+    return ((options) => navigate(
+      getLocalizedOptions(
+        options,
+        pathname,
+        activeLocale,
+        routing,
+        parsedTemplate.localeParamName,
+        parsedTemplate.localeSegment,
+        parsedTemplate.isRequired
+      )
+    ));
+  }
+  function useRouter() {
+    const router = useInjectedRouter();
+    const pathname = useInjectedLocation().pathname;
+    const activeLocale = useLocale();
+    return {
+      ...router,
+      buildLocation(options) {
+        return router.buildLocation(
+          getLocalizedOptions(
+            options,
+            pathname,
+            activeLocale,
+            routing,
+            parsedTemplate.localeParamName,
+            parsedTemplate.localeSegment,
+            parsedTemplate.isRequired
+          )
+        );
+      },
+      navigate(options) {
+        return router.navigate(
+          getLocalizedOptions(
+            options,
+            pathname,
+            activeLocale,
+            routing,
+            parsedTemplate.localeParamName,
+            parsedTemplate.localeSegment,
+            parsedTemplate.isRequired
+          )
+        );
+      },
+      preloadRoute(options) {
+        return router.preloadRoute?.(
+          getLocalizedOptions(
+            options,
+            pathname,
+            activeLocale,
+            routing,
+            parsedTemplate.localeParamName,
+            parsedTemplate.localeSegment,
+            parsedTemplate.isRequired
+          )
+        );
+      }
+    };
+  }
+  return {
+    Link,
+    getPathname,
+    useLocale,
+    useNavigate,
+    usePathname,
+    useRouter
+  };
+}
+function getLocalizedOptions(options, currentPathname, activeLocale, routing, localeParamName, localeSegment, isRequired) {
+  const nextLocale = options.locale ?? activeLocale;
+  const localized = {
+    ...options
+  };
+  delete localized.locale;
+  if (!shouldLocalizeTarget(
+    options.to,
+    currentPathname,
+    routing,
+    localeParamName,
+    localeSegment
+  )) {
+    return localized;
+  }
+  if (typeof options.to === "string" && shouldRewriteTo(options.to) && !pathContainsLocaleParam(options.to, localeParamName)) {
+    localized.to = localizePathname(
+      options.to,
+      nextLocale,
+      routing
+    );
+  }
+  localized.params = localizeParams(
+    options.params,
+    localeParamName,
+    isRequired ? nextLocale : nextLocale === routing.defaultLocale ? void 0 : nextLocale
+  );
+  return localized;
+}
+function localizeParams(params, localeParamName, locale) {
+  if (params === true || params === void 0) {
+    return (current) => mergeLocaleParam(current, localeParamName, locale);
+  }
+  if (typeof params === "function") {
+    return (current) => mergeLocaleParam(
+      params(
+        current
+      ),
+      localeParamName,
+      locale
+    );
+  }
+  if (params && typeof params === "object") {
+    return mergeLocaleParam(
+      params,
+      localeParamName,
+      locale
+    );
+  }
+  return params;
+}
+function mergeLocaleParam(params, localeParamName, locale) {
+  const nextParams = {
+    ...params ?? {}
+  };
+  if (locale === void 0) {
+    delete nextParams[localeParamName];
+    return nextParams;
+  }
+  nextParams[localeParamName] = locale;
+  return nextParams;
+}
+function shouldLocalizeTarget(to, currentPathname, routing, localeParamName, localeSegment) {
+  if (typeof to !== "string" || to === "" || to === "." || to.startsWith(".")) {
+    return isPathnameInScope(currentPathname, routing);
+  }
+  if (to.startsWith("#") || to.startsWith("?")) {
+    return isPathnameInScope(currentPathname, routing);
+  }
+  if (isAbsoluteHref(to)) {
+    return false;
+  }
+  const { pathname } = splitHrefString(to);
+  const normalizedPathname = stripLocalePlaceholder(
+    pathname,
+    localeParamName,
+    localeSegment
+  );
+  return isPathnameInScope(normalizedPathname, routing);
+}
+function pathContainsLocaleParam(to, localeParamName) {
+  return to.split("/").some((s) => s === `$${localeParamName}` || s === `{$${localeParamName}}`);
+}
+function shouldRewriteTo(to) {
+  return !to.startsWith(".") && !to.startsWith("#") && !to.startsWith("?") && !isAbsoluteHref(to);
+}
+function stripLocalePlaceholder(pathname, localeParamName, localeSegment) {
+  const localeTokens = /* @__PURE__ */ new Set([
+    localeSegment,
+    `$${localeParamName}`,
+    `{$${localeParamName}}`
+  ]);
+  const segments = pathname.split("/").filter(Boolean).filter((segment) => !localeTokens.has(segment));
+  return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+function resolveActiveLocale(params, routing, localeParamName) {
+  const localeParam = params[localeParamName];
+  if (typeof localeParam === "string" && routing.locales.includes(localeParam)) {
+    return localeParam;
+  }
+  return routing.defaultLocale;
+}
+export {
+  createNavigationFunctions
+};

package/dist/server.cjs

@@ -0,0 +1,121 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  createServerHelpers: () => createServerHelpers,
+  getRequestConfig: () => getRequestConfig,
+  setRequestLocale: () => setRequestLocale
+});
+module.exports = __toCommonJS(server_exports);
+var import_react = require("react");
+var import_server = require("@better-translate/core/server");
+function getRequestConfig(factory) {
+  return factory;
+}
+function setRequestLocale(locale) {
+  (0, import_server.setRequestLocale)(locale);
+}
+function createServerHelpers(requestConfig) {
+  const readRequestConfig = (0, import_react.cache)(async () => {
+    const resolved = await requestConfig();
+    const translator = resolved.translator;
+    return {
+      locale: resolved.locale,
+      translator
+    };
+  });
+  async function getResolvedLocale(options) {
+    const { locale: configLocale, translator } = await readRequestConfig();
+    return (0, import_server.resolveRequestLocale)(translator, {
+      locale: options?.config?.locale ?? options?.locale,
+      requestLocale: (0, import_server.getRequestLocale)(),
+      configLocale
+    });
+  }
+  async function getDirection(options) {
+    const [{ translator }, locale] = await Promise.all([
+      readRequestConfig(),
+      getResolvedLocale(options)
+    ]);
+    return translator.getDirection({
+      config: typeof options?.config?.rtl === "boolean" ? {
+        rtl: options.config.rtl
+      } : void 0,
+      locale
+    });
+  }
+  async function isRtl(options) {
+    return await getDirection(options) === "rtl";
+  }
+  return {
+    async getAvailableLanguages() {
+      return (await readRequestConfig()).translator.getAvailableLanguages();
+    },
+    getDirection,
+    async getLocale() {
+      return getResolvedLocale();
+    },
+    async getMessages() {
+      const [{ translator }, locale] = await Promise.all([
+        readRequestConfig(),
+        getResolvedLocale()
+      ]);
+      const loadedMessages = await translator.loadLocale(locale);
+      const cachedMessages = translator.getMessages()[locale];
+      if (loadedMessages) {
+        return loadedMessages;
+      }
+      if (cachedMessages) {
+        return cachedMessages;
+      }
+      throw new Error(
+        `Locale "${locale}" messages are not available. Preload them or register a loader in your Better Translate core config.`
+      );
+    },
+    isRtl,
+    async getTranslations(options) {
+      const [{ translator }, locale] = await Promise.all([
+        readRequestConfig(),
+        getResolvedLocale(options)
+      ]);
+      await translator.loadLocale(locale);
+      return ((...args) => {
+        const [key, translateOptions] = args;
+        return translator.t(
+          key,
+          {
+            ...translateOptions ?? {},
+            locale
+          }
+        );
+      });
+    },
+    async getTranslator() {
+      return (await readRequestConfig()).translator;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServerHelpers,
+  getRequestConfig,
+  setRequestLocale
+});

package/dist/server.d.cts

@@ -0,0 +1,30 @@
+import { ConfiguredTranslator, TranslationMessages, TranslationLanguageMetadata, TranslationConfig, TranslationDirection, DeepPartialMessages } from '@better-translate/core';
+
+type AnyTranslator = ConfiguredTranslator<any, TranslationMessages>;
+type InferTranslatorLocale<TTranslator> = TTranslator extends ConfiguredTranslator<infer TLocale, TranslationMessages> ? TLocale : never;
+type InferTranslatorMessages<TTranslator> = TTranslator extends ConfiguredTranslator<string, infer TMessages> ? TMessages : TranslationMessages;
+interface BetterTranslateRequestConfig<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>> {
+    locale?: TLocale;
+    translator: TTranslator;
+}
+type RequestConfigFactory<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>> = () => BetterTranslateRequestConfig<TTranslator, TLocale> | Promise<BetterTranslateRequestConfig<TTranslator, TLocale>>;
+type RequestDirectionOptions<TLocale extends string> = {
+    locale?: TLocale;
+    config?: TranslationConfig<TLocale>;
+};
+interface ServerHelpers<TRequestLocale extends string, TTranslator extends AnyTranslator> {
+    getAvailableLanguages(): Promise<readonly TranslationLanguageMetadata<InferTranslatorLocale<TTranslator>>[]>;
+    getDirection(options?: RequestDirectionOptions<InferTranslatorLocale<TTranslator>>): Promise<TranslationDirection>;
+    getLocale(): Promise<TRequestLocale>;
+    getMessages(): Promise<DeepPartialMessages<InferTranslatorMessages<TTranslator>> | InferTranslatorMessages<TTranslator>>;
+    isRtl(options?: RequestDirectionOptions<InferTranslatorLocale<TTranslator>>): Promise<boolean>;
+    getTranslations(options?: {
+        locale?: InferTranslatorLocale<TTranslator>;
+    }): Promise<TTranslator["t"]>;
+    getTranslator(): Promise<TTranslator>;
+}
+declare function getRequestConfig<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>>(factory: RequestConfigFactory<TTranslator, TLocale>): RequestConfigFactory<TTranslator, TLocale>;
+declare function setRequestLocale<TLocale extends string>(locale: TLocale | undefined): void;
+declare function createServerHelpers<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>>(requestConfig: RequestConfigFactory<TTranslator, TLocale>): ServerHelpers<TLocale, TTranslator>;
+
+export { type BetterTranslateRequestConfig, type RequestConfigFactory, type ServerHelpers, createServerHelpers, getRequestConfig, setRequestLocale };

package/dist/server.d.ts

@@ -0,0 +1,30 @@
+import { ConfiguredTranslator, TranslationMessages, TranslationLanguageMetadata, TranslationConfig, TranslationDirection, DeepPartialMessages } from '@better-translate/core';
+
+type AnyTranslator = ConfiguredTranslator<any, TranslationMessages>;
+type InferTranslatorLocale<TTranslator> = TTranslator extends ConfiguredTranslator<infer TLocale, TranslationMessages> ? TLocale : never;
+type InferTranslatorMessages<TTranslator> = TTranslator extends ConfiguredTranslator<string, infer TMessages> ? TMessages : TranslationMessages;
+interface BetterTranslateRequestConfig<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>> {
+    locale?: TLocale;
+    translator: TTranslator;
+}
+type RequestConfigFactory<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>> = () => BetterTranslateRequestConfig<TTranslator, TLocale> | Promise<BetterTranslateRequestConfig<TTranslator, TLocale>>;
+type RequestDirectionOptions<TLocale extends string> = {
+    locale?: TLocale;
+    config?: TranslationConfig<TLocale>;
+};
+interface ServerHelpers<TRequestLocale extends string, TTranslator extends AnyTranslator> {
+    getAvailableLanguages(): Promise<readonly TranslationLanguageMetadata<InferTranslatorLocale<TTranslator>>[]>;
+    getDirection(options?: RequestDirectionOptions<InferTranslatorLocale<TTranslator>>): Promise<TranslationDirection>;
+    getLocale(): Promise<TRequestLocale>;
+    getMessages(): Promise<DeepPartialMessages<InferTranslatorMessages<TTranslator>> | InferTranslatorMessages<TTranslator>>;
+    isRtl(options?: RequestDirectionOptions<InferTranslatorLocale<TTranslator>>): Promise<boolean>;
+    getTranslations(options?: {
+        locale?: InferTranslatorLocale<TTranslator>;
+    }): Promise<TTranslator["t"]>;
+    getTranslator(): Promise<TTranslator>;
+}
+declare function getRequestConfig<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>>(factory: RequestConfigFactory<TTranslator, TLocale>): RequestConfigFactory<TTranslator, TLocale>;
+declare function setRequestLocale<TLocale extends string>(locale: TLocale | undefined): void;
+declare function createServerHelpers<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>>(requestConfig: RequestConfigFactory<TTranslator, TLocale>): ServerHelpers<TLocale, TTranslator>;
+
+export { type BetterTranslateRequestConfig, type RequestConfigFactory, type ServerHelpers, createServerHelpers, getRequestConfig, setRequestLocale };

package/dist/server.js

@@ -0,0 +1,98 @@
+// src/server.ts
+import { cache } from "react";
+import {
+  getRequestLocale as getStoredRequestLocale,
+  resolveRequestLocale,
+  setRequestLocale as setStoredRequestLocale
+} from "@better-translate/core/server";
+function getRequestConfig(factory) {
+  return factory;
+}
+function setRequestLocale(locale) {
+  setStoredRequestLocale(locale);
+}
+function createServerHelpers(requestConfig) {
+  const readRequestConfig = cache(async () => {
+    const resolved = await requestConfig();
+    const translator = resolved.translator;
+    return {
+      locale: resolved.locale,
+      translator
+    };
+  });
+  async function getResolvedLocale(options) {
+    const { locale: configLocale, translator } = await readRequestConfig();
+    return resolveRequestLocale(translator, {
+      locale: options?.config?.locale ?? options?.locale,
+      requestLocale: getStoredRequestLocale(),
+      configLocale
+    });
+  }
+  async function getDirection(options) {
+    const [{ translator }, locale] = await Promise.all([
+      readRequestConfig(),
+      getResolvedLocale(options)
+    ]);
+    return translator.getDirection({
+      config: typeof options?.config?.rtl === "boolean" ? {
+        rtl: options.config.rtl
+      } : void 0,
+      locale
+    });
+  }
+  async function isRtl(options) {
+    return await getDirection(options) === "rtl";
+  }
+  return {
+    async getAvailableLanguages() {
+      return (await readRequestConfig()).translator.getAvailableLanguages();
+    },
+    getDirection,
+    async getLocale() {
+      return getResolvedLocale();
+    },
+    async getMessages() {
+      const [{ translator }, locale] = await Promise.all([
+        readRequestConfig(),
+        getResolvedLocale()
+      ]);
+      const loadedMessages = await translator.loadLocale(locale);
+      const cachedMessages = translator.getMessages()[locale];
+      if (loadedMessages) {
+        return loadedMessages;
+      }
+      if (cachedMessages) {
+        return cachedMessages;
+      }
+      throw new Error(
+        `Locale "${locale}" messages are not available. Preload them or register a loader in your Better Translate core config.`
+      );
+    },
+    isRtl,
+    async getTranslations(options) {
+      const [{ translator }, locale] = await Promise.all([
+        readRequestConfig(),
+        getResolvedLocale(options)
+      ]);
+      await translator.loadLocale(locale);
+      return ((...args) => {
+        const [key, translateOptions] = args;
+        return translator.t(
+          key,
+          {
+            ...translateOptions ?? {},
+            locale
+          }
+        );
+      });
+    },
+    async getTranslator() {
+      return (await readRequestConfig()).translator;
+    }
+  };
+}
+export {
+  createServerHelpers,
+  getRequestConfig,
+  setRequestLocale
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@better-translate/tanstack-router",
+  "version": "1.0.0",
+  "description": "TanStack Router integration package for Better Translate.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./navigation": {
+      "types": "./dist/navigation.d.ts",
+      "import": "./dist/navigation.js",
+      "require": "./dist/navigation.cjs"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js",
+      "require": "./dist/server.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": ["dist", "LICENSE", "README.md"],
+  "scripts": {
+    "build": "tsup src/index.ts src/navigation.tsx src/server.ts --format esm,cjs --dts --clean",
+    "check-types": "tsc --noEmit",
+    "test": "bun test tests/runtime",
+    "test:types": "tsc -p tests/types/tsconfig.json --noEmit"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jralvarenga/better-translate.git",
+    "directory": "packages/tanstack-router"
+  },
+  "homepage": "https://github.com/jralvarenga/better-translate/tree/main/packages/tanstack-router#readme",
+  "bugs": {
+    "url": "https://github.com/jralvarenga/better-translate/issues"
+  },
+  "dependencies": {
+    "@better-translate/core": "workspace:^"
+  },
+  "peerDependencies": {
+    "@tanstack/react-router": "^1.167.3",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@repo/typescript-config": "*"
+  },
+  "keywords": [
+    "i18n",
+    "l10n",
+    "tanstack-router",
+    "tanstack-start",
+    "translations",
+    "typescript"
+  ]
+}