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

package/src/router-binding/routerOptions.ts

@@ -0,0 +1,26 @@
+import type { RouterHistory } from '@tanstack/history';
+import type {
+  AnyRoute,
+  RouterOptions as CoreRouterOptions,
+  TrailingSlashOption,
+} from '@tanstack/router-core';
+
+/** Native managed hydration transfers immutable public data only. */
+export type RouterOptions<
+  TRouteTree extends AnyRoute,
+  TTrailingSlashOption extends TrailingSlashOption,
+  TDefaultStructuralSharingOption extends boolean = false,
+  TRouterHistory extends RouterHistory = RouterHistory,
+  TDehydrated = undefined,
+> = Omit<
+  CoreRouterOptions<
+    TRouteTree,
+    TTrailingSlashOption,
+    TDefaultStructuralSharingOption,
+    TRouterHistory,
+    TDehydrated
+  >,
+  'serializationAdapters'
+> & {
+  serializationAdapters?: never;
+};

package/src/router-binding/useLoaderData.tsx

@@ -41,10 +41,11 @@ export function useLoaderData<
   opts: UseLoaderDataOptions<TRouter, TFrom, TStrict, TSelected>,
 ): Accessor<UseLoaderDataResult<TRouter, TFrom, TStrict, TSelected>> {
   return useMatch({
-    from: opts.from!,
-    strict: opts.strict,
+    ...opts,
     select: match => {
-      return opts.select ? opts.select(match.loaderData) : match.loaderData;
+      // The hook reads the rendered match; router-core also types pending
+      // matches, where loaderData is optional, in this shared match shape.
+      return opts.select ? opts.select(match.loaderData!) : match.loaderData;
     },
   }) as any;
 }

package/src/router-binding/useNavigate.tsx

@@ -16,12 +16,14 @@ export function useNavigate<
 }): UseNavigateResult<TDefaultFrom> {
   const router = useRouter();
 
-  return ((options: NavigateOptions) => {
+  const navigate: UseNavigateResult<TDefaultFrom> = options => {
+    const from = options.from ?? _defaultOpts?.from;
     return router.navigate({
       ...options,
-      from: options.from ?? _defaultOpts?.from,
+      ...(from === undefined ? {} : { from }),
     });
-  }) as UseNavigateResult<TDefaultFrom>;
+  };
+  return navigate;
 }
 
 export function Navigate<

package/src/router-binding/useParams.tsx

@@ -61,9 +61,7 @@ export function useParams<
   ThrowOrOptional<UseParamsResult<TRouter, TFrom, TStrict, TSelected>, TThrow>
 > {
   return useMatch({
-    from: opts.from!,
-    strict: opts.strict,
-    shouldThrow: opts.shouldThrow,
+    ...opts,
     select: match => {
       const params = opts.strict === false ? match.params : match._strictParams;
       return opts.select ? opts.select(params) : params;

package/src/router-binding/useSearch.tsx

@@ -61,9 +61,7 @@ export function useSearch<
   ThrowOrOptional<UseSearchResult<TRouter, TFrom, TStrict, TSelected>, TThrow>
 > {
   return useMatch({
-    from: opts.from!,
-    strict: opts.strict,
-    shouldThrow: opts.shouldThrow,
+    ...opts,
     select: match => {
       const search = match.search;
       return opts.select ? opts.select(search) : search;

package/src/router.ts

@@ -77,11 +77,11 @@ export interface FileSystemRouteModule {
   pendingComponent?: RouteComponent;
   errorComponent?: ErrorRouteComponent;
   notFoundComponent?: NotFoundRouteComponent;
-  head?: AnyRoute['options']['head'];
+  head?: NonNullable<AnyRoute['options']['head']>;
   /** Explicit returned context becomes immutable public native route context. */
-  beforeLoad?: AnyRoute['options']['beforeLoad'];
+  beforeLoad?: NonNullable<AnyRoute['options']['beforeLoad']>;
   /** Native synchronous context contributions are checked before composition. */
-  context?: AnyRoute['options']['context'];
+  context?: NonNullable<AnyRoute['options']['context']>;
   validateSearch?: (search: Record<string, unknown>) => Record<string, unknown>;
 }