@bleedingdev/modern-js-renderer-octane 3.9.3-ultramodern.7 → 3.9.3-ultramodern.9

package/src/i18n/LocalizedLink.ts

@@ -1,10 +1,10 @@
 import {
-  canonicalPath,
   configuredLanguage,
   localizePath,
 } from '@modern-js/i18n-runtime-extensions/paths';
 import { createElement, hookSlots, type OctaneNode, useContext } from 'octane';
 import {
+  type AnyRouter,
   Link,
   type LinkComponentProps,
   useLocation,
@@ -14,41 +14,23 @@ import { I18nContext } from './context';
 
 // Plain TypeScript is not rewritten by the Octane compiler: router hooks take
 // their stable slot explicitly.
-const locationSlot = Symbol(hookSlots(1));
+const targetLocationSlot = Symbol(hookSlots(1));
 
-export interface LocalizedLinkProps {
+export interface LocalizedLinkProps
+  extends Omit<
+    LinkComponentProps<'a', AnyRouter, string, string>,
+    'to' | 'mask' | 'href' | 'publicHref' | '_fromLocation'
+  > {
   /** A canonical, language-agnostic target, e.g. `/products/red-shoe`. */
   to: string;
   /** Localize for a specific language instead of the current one. */
   language?: string;
-  children?: unknown;
-  class?: string;
-  activeProps?: LinkComponentProps<'a'>['activeProps'];
-  inactiveProps?: LinkComponentProps<'a'>['inactiveProps'];
-  activeOptions?: LinkComponentProps<'a'>['activeOptions'];
-  replace?: boolean;
-  preload?: LinkComponentProps<'a'>['preload'];
 }
 
 /**
- * A thin wrapper over the native Octane router `Link`
- * (`@octanejs/tanstack-router`'s precompiled `Link.tsrx`) that localizes a
- * canonical `to` for the current (or an explicit) language before handing it
- * to the real link — the same contract as `@modern-js/plugin-i18n`'s React
- * `Link`. It resolves the href itself via the shared pathname helpers, so it
- * works with or without the router's i18n `rewrite`. Every link, including
- * one to another language, is the native `Link`: navigation, preloading and
- * active state stay with the router.
- *
- * Under the i18n `rewrite` the router matches canonical paths and localizes
- * outgoing locations to the current language, so a link to another language
- * routes to the canonical `to` and publishes the target language's URL as a
- * route mask (the rewrite keeps a mask's explicit language). The entry's
- * router language synchronization (`syncWithRouter`) switches the i18next
- * instance from the navigated URL, as it does for history navigation.
- *
- * No JSX: built with `createElement`, matching this package's existing
- * style (see `src/routes.ts`).
+ * The native router owns client navigation, preloading and active state. Its mask
+ * keeps the canonical route while publishing the selected language URL;
+ * the entry's i18n router subscription synchronizes the instance on navigation.
  */
 export function LocalizedLink(props: LocalizedLinkProps): OctaneNode {
   const context = useContext(I18nContext);
@@ -58,55 +40,47 @@ export function LocalizedLink(props: LocalizedLinkProps): OctaneNode {
     );
   }
   const router = useRouter();
-
-  // An explicit language must be configured: it becomes the locale prefix.
+  const location = useLocation(undefined, targetLocationSlot);
+  const { language: requestedLanguage, to, children, ...options } = props;
   const language =
-    props.language === undefined
+    requestedLanguage === undefined
       ? context.language
-      : configuredLanguage(props.language, context.languages);
-  const href = localizePath(props.to, language, {
-    languages: [...context.languages],
-    localisedUrls: context.localisedUrls,
-  });
-  const crossLanguage = language !== context.language;
-  const rewrite = Boolean(router.options.rewrite);
+      : configuredLanguage(requestedLanguage, context.languages);
+  const externalTarget = to.startsWith('//') || URL.canParse(to);
+  const pathname = externalTarget
+    ? to
+    : localizePath(
+        router.buildLocation({
+          to,
+          from: options.from,
+          params: options.params,
+          unsafeRelative: options.unsafeRelative,
+          _fromLocation: location,
+        }).pathname,
+        language,
+        {
+          languages: [...context.languages],
+          localisedUrls: context.localisedUrls,
+        },
+      );
 
   return createElement(
-    Link,
+    Link<AnyRouter, string, string, string, string>,
     {
-      // Octane's `Link` builds its location from `to` alone. Under the i18n
-      // router rewrite the router matches canonical paths and localizes the
-      // public href itself; without it, the localized path is the route path.
-      to: rewrite ? props.to : href,
-      ...(rewrite && crossLanguage ? { mask: { to: href } } : {}),
-      ...(crossLanguage ? { hreflang: language } : {}),
-      class: props.class,
-      activeProps: props.activeProps,
-      inactiveProps: props.inactiveProps,
-      activeOptions: props.activeOptions,
-      replace: props.replace,
-      preload: props.preload,
+      ...options,
+      to: router.options.rewrite ? to : pathname,
+      ...(router.options.rewrite && !externalTarget
+        ? {
+            mask: {
+              to: pathname,
+              inheritSearch: true,
+              hash: options.hash,
+              state: options.state,
+            },
+          }
+        : {}),
+      ...(language === context.language ? {} : { hreflang: language }),
     },
-    props.children,
-  );
-}
-
-/**
- * Language-invariant active check: `to="/products"` is active whether the
- * current location is `/en/products` or `/produkty` under a mapped locale.
- */
-export function useIsLocalizedActive(canonicalTarget: string): boolean {
-  const context = useContext(I18nContext);
-  if (!context) {
-    throw new Error(
-      '[renderer-octane] useIsLocalizedActive was used outside of an I18nProvider.',
-    );
-  }
-  const location = useLocation(undefined, locationSlot);
-  return (
-    canonicalPath(location.pathname, {
-      languages: [...context.languages],
-      localisedUrls: context.localisedUrls,
-    }) === canonicalTarget
+    children,
   );
 }

package/src/i18n/context.ts

@@ -6,7 +6,7 @@ export type { I18nContextValue, I18nInstanceLike } from './types';
 /**
  * Octane's `createContext<T>(defaultValue: T)` requires a default (unlike
  * Solid 2's default-less form), so a missing provider is detected by
- * checking for `null` in `useI18n`/`useIsLocalizedActive` instead — the same
+ * checking for `null` in `useI18n`/`LocalizedLink` instead — the same
  * guard shape `@modern-js/plugin-i18n`'s React `ModernI18nContext` uses.
  */
 export const I18nContext = createContext<I18nContextValue | null>(null);

package/src/i18n/index.ts

@@ -22,11 +22,7 @@ export {
 } from '@modern-js/i18n-runtime-extensions/urlRewrite';
 export { I18nContext } from './context';
 export { I18nProvider, type I18nProviderProps } from './I18nProvider';
-export {
-  LocalizedLink,
-  type LocalizedLinkProps,
-  useIsLocalizedActive,
-} from './LocalizedLink';
+export { LocalizedLink, type LocalizedLinkProps } from './LocalizedLink';
 export {
   type OctaneLatestLanguageSyncOptions,
   useLatestLanguageSync,