@tanstack/router-core 1.132.0-alpha.8 → 1.132.2

package/src/scroll-restoration.ts

@@ -358,7 +358,7 @@ export function setupScrollRestoration(router: AnyRouter, force?: boolean) {
 }
 
 /**
- * @internal
+ * @private
  * Handles hash-based scrolling after navigation completes.
  * To be used in framework-specific <Transitioner> components during the onResolved event.
  *

package/src/ssr/createRequestHandler.ts

@@ -21,7 +21,10 @@ export function createRequestHandler<TRouter extends AnyRouter>({
   return async (cb) => {
     const router = createRouter()
 
-    attachRouterServerSsrUtils(router, await getRouterManifest?.())
+    attachRouterServerSsrUtils({
+      router,
+      manifest: await getRouterManifest?.(),
+    })
 
     const url = new URL(request.url, 'http://localhost')
 

package/src/ssr/serializer/transformer.ts

@@ -1,7 +1,7 @@
 import { createPlugin } from 'seroval'
 import { GLOBAL_TSR } from '../constants'
 import type { Plugin, SerovalNode } from 'seroval'
-import type { Register, SSROption } from '../../router'
+import type { RegisteredConfigType, SSROption } from '../../router'
 import type { LooseReturnType } from '../../utils'
 import type { AnyRoute, ResolveAllSSR } from '../../route'
 
@@ -151,12 +151,12 @@ export function makeSerovalPlugin<TInput, TOutput>(
   })
 }
 
-export type ValidateSerializableInput<
-  TRegister extends Register,
+export type ValidateSerializableInput<TRegister, T> = ValidateSerializable<
   T,
-> = ValidateSerializable<T, RegisteredSerializableInput<TRegister>>
+  RegisteredSerializableInput<TRegister>
+>
 
-export type RegisteredSerializableInput<TRegister extends Register> =
+export type RegisteredSerializableInput<TRegister> =
   | (unknown extends RegisteredSerializationAdapters<TRegister>
       ? never
       : RegisteredSerializationAdapters<TRegister> extends ReadonlyArray<AnySerializationAdapter>
@@ -164,13 +164,13 @@ export type RegisteredSerializableInput<TRegister extends Register> =
         : never)
   | Serializable
 
-export type RegisteredSerializationAdapters<TRegister extends Register> =
-  TRegister['config']['~types']['serializationAdapters']
+export type RegisteredSerializationAdapters<TRegister> = RegisteredConfigType<
+  TRegister,
+  'serializationAdapters'
+>
 
-export type ValidateSerializableInputResult<
-  TRegister extends Register,
-  T,
-> = ValidateSerializableResult<T, RegisteredSerializableInput<TRegister>>
+export type ValidateSerializableInputResult<TRegister, T> =
+  ValidateSerializableResult<T, RegisteredSerializableInput<TRegister>>
 
 export type ValidateSerializableResult<T, TSerializable> =
   T extends TSerializable
@@ -181,17 +181,17 @@ export type ValidateSerializableResult<T, TSerializable> =
         ? ReadableStream
         : { [K in keyof T]: ValidateSerializableResult<T[K], TSerializable> }
 
-export type RegisteredSSROption<TRegister extends Register> =
-  unknown extends TRegister['config']['~types']['defaultSsr']
+export type RegisteredSSROption<TRegister> =
+  unknown extends RegisteredConfigType<TRegister, 'defaultSsr'>
     ? SSROption
-    : TRegister['config']['~types']['defaultSsr']
+    : RegisteredConfigType<TRegister, 'defaultSsr'>
 
 export type ValidateSerializableLifecycleResult<
-  TRegister extends Register,
+  TRegister,
   TParentRoute extends AnyRoute,
   TSSR,
   TFn,
-> = false extends TRegister['ssr']
+> = false extends (TRegister extends { ssr: infer TSSR } ? TSSR : never)
   ? any
   : ValidateSerializableLifecycleResultSSR<
         TRegister,
@@ -203,7 +203,7 @@ export type ValidateSerializableLifecycleResult<
     : never
 
 export type ValidateSerializableLifecycleResultSSR<
-  TRegister extends Register,
+  TRegister,
   TParentRoute extends AnyRoute,
   TSSR,
   TFn,

package/src/ssr/server.ts

@@ -9,8 +9,8 @@ export {
 } from './transformStreamWithRouter'
 export { attachRouterServerSsrUtils } from './ssr-server'
 
-declare module '../router' {
-  export interface Register {
-    ssr: true
-  }
-}
+// declare module '../router' {
+//   export interface RegisterSsr {
+//     ssr: true
+//   }
+// }

package/src/ssr/ssr-server.ts

@@ -48,10 +48,13 @@ export function dehydrateMatch(match: AnyRouteMatch): DehydratedMatch {
   return dehydratedMatch
 }
 
-export function attachRouterServerSsrUtils(
-  router: AnyRouter,
-  manifest: Manifest | undefined,
-) {
+export function attachRouterServerSsrUtils({
+  router,
+  manifest,
+}: {
+  router: AnyRouter
+  manifest: Manifest | undefined
+}) {
   router.ssr = {
     manifest,
   }
@@ -81,7 +84,7 @@ export function attachRouterServerSsrUtils(
     injectScript: (getScript) => {
       return router.serverSsr!.injectHtml(async () => {
         const script = await getScript()
-        return `<script class='$tsr'>${getInitialScript()}${script};$_TSR.c()</script>`
+        return `<script ${router.options.ssr?.nonce ? `nonce='${router.options.ssr.nonce}'` : ''} class='$tsr'>${getInitialScript()}${script};$_TSR.c()</script>`
       })
     },
     dehydrate: async () => {

package/src/utils.ts

@@ -203,6 +203,8 @@ export function functionalUpdate<TPrevious, TResult = TPrevious>(
   return updater
 }
 
+const hasOwn = Object.prototype.hasOwnProperty
+
 /**
  * This function returns `prev` if `_next` is deeply equal.
  * If not, it will replace any deeply equal children of `b` with those of `a`.
@@ -218,57 +220,64 @@ export function replaceEqualDeep<T>(prev: any, _next: T): T {
 
   const array = isPlainArray(prev) && isPlainArray(next)
 
-  if (array || (isSimplePlainObject(prev) && isSimplePlainObject(next))) {
-    const prevItems = array
-      ? prev
-      : (Object.keys(prev) as Array<unknown>).concat(
-          Object.getOwnPropertySymbols(prev),
-        )
-    const prevSize = prevItems.length
-    const nextItems = array
-      ? next
-      : (Object.keys(next) as Array<unknown>).concat(
-          Object.getOwnPropertySymbols(next),
-        )
-    const nextSize = nextItems.length
-    const copy: any = array ? [] : {}
-
-    let equalItems = 0
-
-    for (let i = 0; i < nextSize; i++) {
-      const key = array ? i : (nextItems[i] as any)
-      if (
-        ((!array && prevItems.includes(key)) || array) &&
-        prev[key] === undefined &&
-        next[key] === undefined
-      ) {
-        copy[key] = undefined
-        equalItems++
-      } else {
-        copy[key] = replaceEqualDeep(prev[key], next[key])
-        if (copy[key] === prev[key] && prev[key] !== undefined) {
-          equalItems++
-        }
-      }
+  if (!array && !(isPlainObject(prev) && isPlainObject(next))) return next
+
+  const prevItems = array ? prev : getEnumerableOwnKeys(prev)
+  if (!prevItems) return next
+  const nextItems = array ? next : getEnumerableOwnKeys(next)
+  if (!nextItems) return next
+  const prevSize = prevItems.length
+  const nextSize = nextItems.length
+  const copy: any = array ? new Array(nextSize) : {}
+
+  let equalItems = 0
+
+  for (let i = 0; i < nextSize; i++) {
+    const key = array ? i : (nextItems[i] as any)
+    const p = prev[key]
+    const n = next[key]
+
+    if (p === n) {
+      copy[key] = p
+      if (array ? i < prevSize : hasOwn.call(prev, key)) equalItems++
+      continue
+    }
+
+    if (
+      p === null ||
+      n === null ||
+      typeof p !== 'object' ||
+      typeof n !== 'object'
+    ) {
+      copy[key] = n
+      continue
     }
 
-    return prevSize === nextSize && equalItems === prevSize ? prev : copy
+    const v = replaceEqualDeep(p, n)
+    copy[key] = v
+    if (v === p) equalItems++
   }
 
-  return next
+  return prevSize === nextSize && equalItems === prevSize ? prev : copy
 }
 
 /**
- * A wrapper around `isPlainObject` with additional checks to ensure that it is not
- * only a plain object, but also one that is "clone-friendly" (doesn't have any
- * non-enumerable properties).
+ * Equivalent to `Reflect.ownKeys`, but ensures that objects are "clone-friendly":
+ * will return false if object has any non-enumerable properties.
  */
-function isSimplePlainObject(o: any) {
-  return (
-    // all the checks from isPlainObject are more likely to hit so we perform them first
-    isPlainObject(o) &&
-    Object.getOwnPropertyNames(o).length === Object.keys(o).length
-  )
+function getEnumerableOwnKeys(o: object) {
+  const keys = []
+  const names = Object.getOwnPropertyNames(o)
+  for (const name of names) {
+    if (!Object.prototype.propertyIsEnumerable.call(o, name)) return false
+    keys.push(name)
+  }
+  const symbols = Object.getOwnPropertySymbols(o)
+  for (const symbol of symbols) {
+    if (!Object.prototype.propertyIsEnumerable.call(o, symbol)) return false
+    keys.push(symbol)
+  }
+  return keys
 }
 
 // Copied from: https://github.com/jonschlinkert/is-plain-object
@@ -306,14 +315,6 @@ export function isPlainArray(value: unknown): value is Array<unknown> {
   return Array.isArray(value) && value.length === Object.keys(value).length
 }
 
-function getObjectKeys(obj: any, ignoreUndefined: boolean) {
-  let keys = Object.keys(obj)
-  if (ignoreUndefined) {
-    keys = keys.filter((key) => obj[key] !== undefined)
-  }
-  return keys
-}
-
 export function deepEqual(
   a: any,
   b: any,
@@ -327,23 +328,44 @@ export function deepEqual(
     return false
   }
 
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false
+    for (let i = 0, l = a.length; i < l; i++) {
+      if (!deepEqual(a[i], b[i], opts)) return false
+    }
+    return true
+  }
+
   if (isPlainObject(a) && isPlainObject(b)) {
     const ignoreUndefined = opts?.ignoreUndefined ?? true
-    const aKeys = getObjectKeys(a, ignoreUndefined)
-    const bKeys = getObjectKeys(b, ignoreUndefined)
 
-    if (!opts?.partial && aKeys.length !== bKeys.length) {
-      return false
+    if (opts?.partial) {
+      for (const k in b) {
+        if (!ignoreUndefined || b[k] !== undefined) {
+          if (!deepEqual(a[k], b[k], opts)) return false
+        }
+      }
+      return true
     }
 
-    return bKeys.every((key) => deepEqual(a[key], b[key], opts))
-  }
+    let aCount = 0
+    if (!ignoreUndefined) {
+      aCount = Object.keys(a).length
+    } else {
+      for (const k in a) {
+        if (a[k] !== undefined) aCount++
+      }
+    }
 
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) {
-      return false
+    let bCount = 0
+    for (const k in b) {
+      if (!ignoreUndefined || b[k] !== undefined) {
+        bCount++
+        if (bCount > aCount || !deepEqual(a[k], b[k], opts)) return false
+      }
     }
-    return !a.some((item, index) => !deepEqual(item, b[index], opts))
+
+    return aCount === bCount
   }
 
   return false