@bleedingdev/modern-js-renderer-solid 3.9.3-ultramodern.1 → 3.9.3-ultramodern.10

package/src/router-binding/link.tsx

@@ -505,9 +505,9 @@ export function useLinkProps<
   }
 
   const defineGetters = (getters: Record<string, () => any>) => {
-    for (const key of Object.keys(getters)) {
+    for (const [key, get] of Object.entries(getters)) {
       Object.defineProperty(linkProps, key, {
-        get: getters[key],
+        get,
         enumerable: true,
         configurable: true,
       });

package/src/router-binding/registryTransfer.ts

@@ -78,8 +78,21 @@ export function registerPublicRouteDataOwner(
   });
 }
 
+/** Managed match transfer uses the immutable public-data contract, not custom adapters. */
+export function assertNativeSerializationOptions(options: object): void {
+  if ('serializationAdapters' in options) {
+    const error = new DataProtocolError(
+      'Solid serializationAdapters are unsupported by the immutable public-data profile; return public records, arrays and scalars instead',
+    );
+    const owner: RequestSession | undefined = getRequestEvent()?.locals.session;
+    owner?.fail(error);
+    throw error;
+  }
+}
+
 /** Framework SSR accepts only routers that passed its public-data factory boundary. */
 export function requireManagedPublicRouter(router: AnyRouter): void {
+  assertNativeSerializationOptions(router.options);
   const owner: RequestSession | undefined = getRequestEvent()?.locals.session;
   if (
     !owner ||
@@ -268,6 +281,11 @@ export function primeRouterFromRegistry(router: AnyRouter): boolean {
   try {
     for (const [index, match] of matches.entries()) {
       const entry = entries[index]!;
+      const beforeLoadContext = preparePublicContextData(
+        entry.beforeLoadContext,
+        owner,
+        privateContexts,
+      ) as Record<string, unknown> | undefined;
       const checked: TransferredMatch = {
         ...entry,
         loaderData: prepareHydratedLoaderData(
@@ -275,11 +293,7 @@ export function primeRouterFromRegistry(router: AnyRouter): boolean {
           owner,
           privateContexts,
         ),
-        beforeLoadContext: preparePublicContextData(
-          entry.beforeLoadContext,
-          owner,
-          privateContexts,
-        ) as Record<string, unknown> | undefined,
+        ...(beforeLoadContext !== undefined ? { beforeLoadContext } : {}),
         error: preparePublicContextData(entry.error, owner, privateContexts),
       };
       entries[index] = checked;
@@ -356,7 +370,10 @@ function applyTransferredMatch(
     __beforeLoadContext: entry.beforeLoadContext,
   } as AnyRouteMatch;
   if ('loaderData' in entry) next.loaderData = entry.loaderData;
-  if ('ssr' in entry) next.ssr = entry.ssr;
+  if ('ssr' in entry) {
+    if (entry.ssr === undefined) delete next.ssr;
+    else next.ssr = entry.ssr;
+  }
   return next;
 }
 

package/src/router-binding/route.tsx

@@ -133,7 +133,7 @@ export class RouteApi<
     return useNavigate({ from: router.routesById[this.id as string].fullPath });
   };
 
-  notFound = (opts?: NotFoundError) => {
+  override notFound = (opts?: NotFoundError) => {
     return notFound({ routeId: this.id as string, ...opts });
   };
 

package/src/router-binding/router.ts

@@ -9,6 +9,7 @@ import type {
 import { RouterCore } from '@tanstack/router-core';
 import { isServer } from '@tanstack/router-core/isServer';
 import {
+  assertNativeSerializationOptions,
   installPublicContextPublication,
   primeRouterFromRegistry,
 } from './registryTransfer';
@@ -104,6 +105,7 @@ export class Router<
       TDehydrated
     >,
   ) {
+    assertNativeSerializationOptions(options);
     super(options, getStoreFactory);
     installPublicContextPublication(this);
     // The hydration-claiming boot (see registryTransfer). Router creation is

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>;
 }