@pyreon/router 0.13.1 → 0.15.0

package/src/tests/loader.test.ts

@@ -581,3 +581,152 @@ describe('router.preload', () => {
     expect(router._componentCache.get(routes[1] as RouteRecord)).toBe(Lazy)
   })
 })
+
+// ─── _loaderCache LRU cap (regression for missing _maxCacheSize wiring) ────
+describe('router — _loaderCache LRU cap', () => {
+  // Pre-fix: `_maxCacheSize` was wired through from `RouterOptions.maxCacheSize`
+  // (default 100) but the loader cache write paths in router.ts never read it
+  // — only `_componentCache` enforced the cap. Long-running SPAs navigating
+  // dynamic-param routes (`/posts/:id` with hundreds of unique IDs) would
+  // accumulate `_loaderCache` entries until manual `invalidateLoader()`.
+  // Post-fix: the helper `loaderCacheSet` evicts oldest (insertion-order FIFO)
+  // when over the cap, mirroring `_componentCache`.
+  test('caps _loaderCache at maxCacheSize, evicts oldest first', async () => {
+    const Page = () => null
+    const routes: RouteRecord[] = [
+      {
+        path: '/posts/:id',
+        component: Page,
+        loader: async ({ params }) => `post-${params.id}`,
+        loaderKey: ({ params }) => `posts:${params.id}`,
+      },
+    ]
+    const router = createRouter({ routes, maxCacheSize: 3, url: '/' }) as RouterInstance
+
+    // Drive the loader through 4 distinct keys
+    await router.push('/posts/1')
+    await router.push('/posts/2')
+    await router.push('/posts/3')
+    await router.push('/posts/4')
+
+    // Cache must be capped at 3 (not 4).
+    expect(router._loaderCache.size).toBe(3)
+
+    // FIFO: the OLDEST insertion (posts:1) must have been evicted.
+    expect(router._loaderCache.has('posts:1')).toBe(false)
+    expect(router._loaderCache.has('posts:2')).toBe(true)
+    expect(router._loaderCache.has('posts:3')).toBe(true)
+    expect(router._loaderCache.has('posts:4')).toBe(true)
+  })
+
+  test('does not evict when cap is not exceeded', async () => {
+    const Page = () => null
+    const routes: RouteRecord[] = [
+      {
+        path: '/posts/:id',
+        component: Page,
+        loader: async ({ params }) => `post-${params.id}`,
+        loaderKey: ({ params }) => `posts:${params.id}`,
+      },
+    ]
+    const router = createRouter({ routes, maxCacheSize: 100, url: '/' }) as RouterInstance
+
+    await router.push('/posts/1')
+    await router.push('/posts/2')
+    await router.push('/posts/3')
+
+    expect(router._loaderCache.size).toBe(3)
+    expect(router._loaderCache.has('posts:1')).toBe(true)
+    expect(router._loaderCache.has('posts:2')).toBe(true)
+    expect(router._loaderCache.has('posts:3')).toBe(true)
+  })
+
+  test('default maxCacheSize (100) caps cache after 100 unique keys', async () => {
+    const Page = () => null
+    const routes: RouteRecord[] = [
+      {
+        path: '/posts/:id',
+        component: Page,
+        loader: async ({ params }) => `post-${params.id}`,
+        loaderKey: ({ params }) => `posts:${params.id}`,
+      },
+    ]
+    // No explicit maxCacheSize — uses default 100
+    const router = createRouter({ routes, url: '/' }) as RouterInstance
+
+    for (let i = 0; i < 105; i++) {
+      await router.push(`/posts/${i}`)
+    }
+
+    expect(router._loaderCache.size).toBe(100)
+    // Earliest 5 keys (0-4) evicted.
+    expect(router._loaderCache.has('posts:0')).toBe(false)
+    expect(router._loaderCache.has('posts:4')).toBe(false)
+    expect(router._loaderCache.has('posts:5')).toBe(true)
+    expect(router._loaderCache.has('posts:104')).toBe(true)
+  })
+})
+
+// ─── Regression: dedup must not return aborted in-flight promise ───────────
+//
+// Pre-fix: `router.push` aborts `_abortController` BEFORE starting the next
+// nav. If two pushes to the same path happen back-to-back, the in-flight
+// Map still holds nav-1's promise (its `.catch` hasn't run yet). The dedup
+// returned that promise to nav-2 — but its bound signal is already aborted,
+// so nav-2's data path is broken even though it has its own fresh signal.
+//
+// Post-fix: `_loaderInflight` stores `{ promise, signal }`. Dedup is gated
+// on `!signal.aborted`. Aborted entries fall through to a fresh execute
+// using nav-2's signal.
+describe('router — _loaderInflight aborted-signal dedup', () => {
+  test('back-to-back navigation re-executes loader with fresh signal when previous was aborted', async () => {
+    let invocations = 0
+    let resolveLoader1: ((data: unknown) => void) | null = null
+
+    const Page = () => null
+    const routes: RouteRecord[] = [
+      { path: '/', component: Page },
+      {
+        path: '/data',
+        component: Page,
+        loader: async ({ signal }) => {
+          invocations++
+          const myInvocation = invocations
+          // Wire signal-abort → reject so the nav actually fails on abort.
+          // The first invocation hangs until manually resolved; later
+          // invocations resolve immediately.
+          if (myInvocation === 1) {
+            return new Promise((_resolve, reject) => {
+              signal?.addEventListener('abort', () => reject(new Error('aborted')))
+              resolveLoader1 = _resolve
+            })
+          }
+          return `data-${myInvocation}`
+        },
+      },
+    ]
+    const router = createRouter({ routes, url: '/' }) as RouterInstance
+
+    // Nav 1 → /data. Loader invocation #1 starts, hangs.
+    const nav1 = router.push('/data').catch(() => {})
+    await new Promise<void>((r) => queueMicrotask(() => r()))
+
+    // Nav 2 → /data. router.push aborts ac1 first, then calls executeLoader.
+    // Pre-fix: dedup returns nav-1's promise (whose signal is now aborted).
+    // Post-fix: dedup skipped (signal.aborted=true), fresh loader runs.
+    const nav2 = router.push('/data')
+
+    // Resolve nav-1's hung promise (won't actually deliver — already aborted)
+    const r1 = resolveLoader1 as ((d: unknown) => void) | null
+    if (r1) r1('data-1')
+
+    await nav2
+    await nav1
+
+    // Post-fix: 2 invocations (nav-1 aborted, nav-2 ran fresh).
+    // Pre-fix: 1 invocation (nav-2 deduped to nav-1's aborted promise).
+    expect(invocations).toBe(2)
+    expect(router.currentRoute().path).toBe('/data')
+  })
+
+})

package/src/tests/manifest-snapshot.test.ts

@@ -87,8 +87,12 @@ describe('gen-docs — router snapshot', () => {
 
   it('renders @pyreon/router to MCP api-reference entries — one per api[] item', () => {
     const record = renderApiReferenceEntries(routerManifest)
-    expect(Object.keys(record).length).toBe(15)
+    expect(Object.keys(record).length).toBe(18)
     expect(Object.keys(record)).toContain('router/createRouter')
+    // PR-B added redirect/isRedirectError/getRedirectInfo entries.
+    expect(Object.keys(record)).toContain('router/redirect')
+    expect(Object.keys(record)).toContain('router/isRedirectError')
+    expect(Object.keys(record)).toContain('router/getRedirectInfo')
     // Spot-check the flagship API — createRouter is the factory
     const createRouter = record['router/createRouter']!
     expect(createRouter.notes).toContain('routes')

package/src/tests/match.test.ts

@@ -465,3 +465,34 @@ describe('resolveRoute — wildcard patterns', () => {
     expect(r.matched[r.matched.length - 1]?.component).toBe(NotFound)
   })
 })
+
+// ─── + as space in query parsing (application/x-www-form-urlencoded) ────────
+
+describe('parseQuery — + as space', () => {
+  it('decodes + as space in values', () => {
+    expect(parseQuery('name=john+doe')).toEqual({ name: 'john doe' })
+  })
+
+  it('decodes + as space in keys', () => {
+    expect(parseQuery('first+name=Alice')).toEqual({ 'first name': 'Alice' })
+  })
+
+  it('handles mixed + and %20', () => {
+    expect(parseQuery('a=hello+world&b=foo%20bar')).toEqual({
+      a: 'hello world',
+      b: 'foo bar',
+    })
+  })
+
+  it('handles multiple + in a value', () => {
+    expect(parseQuery('q=one+two+three')).toEqual({ q: 'one two three' })
+  })
+})
+
+describe('parseQueryMulti — + as space', () => {
+  it('decodes + as space in values', () => {
+    expect(parseQueryMulti('tag=hello+world&tag=foo+bar')).toEqual({
+      tag: ['hello world', 'foo bar'],
+    })
+  })
+})

package/src/tests/native-markers.test.ts

@@ -0,0 +1,18 @@
+import { isNativeCompat } from '@pyreon/core'
+import { describe, expect, it } from 'vitest'
+import { RouterLink, RouterProvider, RouterView } from '../components'
+
+// Marker-presence assertion (PR 3 lock-in). Bisect-verified: removing
+// any of the `nativeCompat(...)` calls in components.tsx fails the
+// corresponding test.
+describe('native-compat markers — @pyreon/router', () => {
+  it('RouterProvider is marked native', () => {
+    expect(isNativeCompat(RouterProvider)).toBe(true)
+  })
+  it('RouterView is marked native', () => {
+    expect(isNativeCompat(RouterView)).toBe(true)
+  })
+  it('RouterLink is marked native', () => {
+    expect(isNativeCompat(RouterLink)).toBe(true)
+  })
+})

package/src/tests/redirect.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest'
+import { getRedirectInfo, isRedirectError, redirect } from '../redirect'
+
+describe('redirect()', () => {
+  it('throws an error branded with the REDIRECT symbol', () => {
+    expect(() => redirect('/login')).toThrow()
+  })
+
+  it('captures URL + default 307 status on the thrown error', () => {
+    let caught: unknown
+    try {
+      redirect('/login')
+    } catch (err) {
+      caught = err
+    }
+    const info = getRedirectInfo(caught)
+    expect(info).toEqual({ url: '/login', status: 307 })
+  })
+
+  it('captures the custom status when one is provided', () => {
+    let caught: unknown
+    try {
+      redirect('/perm', 308)
+    } catch (err) {
+      caught = err
+    }
+    expect(getRedirectInfo(caught)?.status).toBe(308)
+  })
+
+  it.each([301, 302, 303, 307, 308] as const)('accepts %s as a valid status', (status) => {
+    let caught: unknown
+    try {
+      redirect('/x', status)
+    } catch (err) {
+      caught = err
+    }
+    expect(getRedirectInfo(caught)?.status).toBe(status)
+  })
+
+  it('produces a human-readable Error message', () => {
+    let caught: Error | undefined
+    try {
+      redirect('/login')
+    } catch (err) {
+      caught = err as Error
+    }
+    expect(caught?.message).toBe('Redirect to /login')
+  })
+})
+
+describe('isRedirectError()', () => {
+  it('returns true for an error thrown by redirect()', () => {
+    let caught: unknown
+    try {
+      redirect('/x')
+    } catch (err) {
+      caught = err
+    }
+    expect(isRedirectError(caught)).toBe(true)
+  })
+
+  it('returns false for a plain Error', () => {
+    expect(isRedirectError(new Error('plain'))).toBe(false)
+  })
+
+  it('returns false for non-error values', () => {
+    expect(isRedirectError(null)).toBe(false)
+    expect(isRedirectError(undefined)).toBe(false)
+    expect(isRedirectError('string')).toBe(false)
+    expect(isRedirectError(42)).toBe(false)
+    expect(isRedirectError({})).toBe(false)
+  })
+
+  it('returns false for objects with a different brand', () => {
+    const fake = new Error('fake')
+    ;(fake as unknown as Record<symbol, unknown>)[Symbol.for('something.else')] = true
+    expect(isRedirectError(fake)).toBe(false)
+  })
+})
+
+describe('getRedirectInfo()', () => {
+  it('returns null for non-redirect errors', () => {
+    expect(getRedirectInfo(new Error('plain'))).toBeNull()
+    expect(getRedirectInfo(null)).toBeNull()
+  })
+
+  it('returns the redirect info for a thrown redirect()', () => {
+    let caught: unknown
+    try {
+      redirect('/destination', 303)
+    } catch (err) {
+      caught = err
+    }
+    expect(getRedirectInfo(caught)).toEqual({ url: '/destination', status: 303 })
+  })
+})

package/src/tests/router.browser.test.tsx

@@ -1,4 +1,4 @@
-import { h } from '@pyreon/core'
+import { h, onMount } from '@pyreon/core'
 import { flush, mountInBrowser } from '@pyreon/test-utils/browser'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 import {
@@ -439,4 +439,71 @@ describe('router in real browser', () => {
     expect(container.querySelector('#home')).toBeNull()
     unmount()
   })
+
+  // ── Lock-in for the layout-remount loop fix (PR #406) ──────────────────────
+  //
+  // Pre-fix `RouterView`'s reactive child accessor read `_loadingSignal()` and
+  // the full `currentRoute` snapshot directly. Each navigation flow writes
+  // `_loadingSignal` at least twice (start tick + end tick) and writes
+  // `currentPath` once via `commitNavigation`. Any of those writes re-emitted
+  // the reactive child, and `mountReactive`'s teardown-then-mount cleanup
+  // remounted the entire matched-component subtree on each emission. So a
+  // single `router.push()` produced 2-3+ mounts of the destination component
+  // (instead of 1) — the "layout double/triple mount" loop.
+  //
+  // The fix routes the structural decision through a single
+  // `computed<DepthEntry>` keyed on `(rec, comp, errored, route)` reference
+  // equality. Within-navigation `_loadingSignal` ticks don't change
+  // `currentRoute` (it's `computed` memoized on `currentPath`), so the
+  // structural emission stays at exactly one per navigation.
+  //
+  // This test instruments a counter inside the destination component's
+  // `onMount` — an inflated count after a single `await router.push()` would
+  // mean the loop is back. Bisect-verifies against the structural decoupling
+  // commit: reverting that commit pushes the count to ≥ 2 and this assertion
+  // fails.
+  it('a single router.push() mounts the destination component exactly once (loop-prevention regression)', async () => {
+    let aboutMountCount = 0
+    const InstrumentedAbout = () => {
+      onMount(() => {
+        aboutMountCount++
+      })
+      return h('div', { id: 'about-instrumented' }, 'About Page')
+    }
+    const localRoutes = [
+      { path: '/', component: Home },
+      { path: '/about', component: InstrumentedAbout },
+    ]
+    const router = createRouter({ routes: localRoutes, mode: 'hash' })
+    const { container, unmount } = mountInBrowser(
+      h(RouterProvider, { router }, h(RouterView, {})),
+    )
+
+    // Sanity: starting at /, About is not yet mounted.
+    expect(aboutMountCount).toBe(0)
+    expect(container.querySelector('#about-instrumented')).toBeNull()
+
+    await router.push('/about')
+    await flush()
+
+    // The structural decoupling fix means a single navigation produces a
+    // single emission at this depth. If `RouterView` ever reverts to reading
+    // `_loadingSignal` reactively, every loadingSignal tick during the
+    // navigate flow will remount the destination subtree and this count
+    // jumps to 2 or 3.
+    expect(container.querySelector('#about-instrumented')?.textContent).toBe('About Page')
+    expect(aboutMountCount).toBe(1)
+
+    // And navigating BACK to / + forward again to /about produces exactly
+    // one more mount — covers the case where stale subscribers from a prior
+    // mount could double-fire across navigations.
+    await router.push('/')
+    await flush()
+    await router.push('/about')
+    await flush()
+    expect(aboutMountCount).toBe(2)
+
+    expect(unhandledRejections).toEqual([])
+    unmount()
+  })
 })