@jasonshimmy/vite-plugin-cer-app 0.23.2 → 0.25.0

package/dist/runtime/app-template.js

@@ -5,12 +5,15 @@
  * automatically receive the latest bootstrap code on plugin update.
  * This file is gitignored and should never be edited directly.
  */
-export function generateAppEntryTemplate() {
+export function generateAppEntryTemplate(globalImports = []) {
+    const integrationImports = [...new Set(globalImports)]
+        .map((specifier) => `import '${specifier.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`)
+        .join('\n');
     return `// AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app — do not edit.
 // Regenerated automatically on every dev server start and build.
 
 import '@jasonshimmy/custom-elements-runtime/css'
-import 'virtual:cer-jit-css'
+${integrationImports}${integrationImports ? '\n' : ''}import 'virtual:cer-jit-css'
 // virtual:cer-jit-init must run before virtual:cer-layouts and virtual:cer-plugins
 // so JIT CSS is enabled before those modules upgrade custom elements via
 // customElements.define(). Static imports execute depth-first in module order,
@@ -22,7 +25,7 @@ import layouts from 'virtual:cer-layouts'
 import plugins from 'virtual:cer-plugins'
 import { hasLoading, loadingTag } from 'virtual:cer-loading'
 import { hasError, errorTag } from 'virtual:cer-error'
-import { runtimeConfig } from 'virtual:cer-app-config'
+import { runtimeConfig, appConfig } from 'virtual:cer-app-config'
 import {
   component,
   ref,
@@ -53,7 +56,7 @@ registerBuiltinComponents()
 setDevMode(_cerRuntimeDev)
 initRuntimeConfig(runtimeConfig)
 
-const router = initRouter({ routes })
+const router = initRouter({ ...appConfig.router, routes })
 
 // Expose the router globally so useRoute() and navigateTo() can access it
 // from any composable without circular imports.
@@ -66,10 +69,17 @@ const router = initRouter({ routes })
 // the page element directly with the correct attributes (enabling useProps()).
 let _currentPageTag = null
 let _currentPageAttrs = {}
+// Changes only when a page load successfully publishes. Keying the rendered
+// page with this value prevents dynamic/catch-all routes that share one custom
+// element tag from retaining loader-backed state from the previous URL.
+let _currentPageKey = null
 // The pathname this tag was loaded for — used to detect router-internal
 // redirects (e.g. middleware returning '/login') so cer-layout-view falls
 // back to <router-view> when the current route differs from what was pre-loaded.
 let _currentPagePath = null
+// Route chunks and loaders may resolve out of order during rapid navigation or
+// initial hydration. Only the newest request is allowed to publish page state.
+let _pageLoadVersion = 0
 
 function _toLoaderAttrs(data) {
   if (data === undefined || data === null || typeof data !== 'object') return {}
@@ -81,6 +91,7 @@ function _toLoaderAttrs(data) {
 // Pre-loads the page module for \`path\`, calls its loader if present, and
 // stores the results so cer-layout-view can pass them as element attributes.
 async function _loadPageForPath(path, options = {}) {
+  const loadVersion = ++_pageLoadVersion
   try {
     const url = new URL(path, 'http://x')
     const query = Object.fromEntries(url.searchParams)
@@ -88,26 +99,29 @@ async function _loadPageForPath(path, options = {}) {
     const matched = router.matchRoute(url.pathname)
     const route = matched?.route
     if (!route?.load) {
+      if (loadVersion !== _pageLoadVersion) return
       _currentPageTag = null
       _currentPageAttrs = {}
+      _currentPageKey = null
       _currentPagePath = url.pathname
       return
     }
     const mod = await route.load()
-    _currentPageTag = mod.default ?? null
-    _currentPagePath = url.pathname
+    if (loadVersion !== _pageLoadVersion) return
     const params = matched.params ?? {}
     let loaderAttrs = { ...params }
     let loaderData = initialData
+    let hasFreshLoaderData = false
     if (typeof mod.loader === 'function' && runLoader) {
       try {
         const data = await mod.loader({ params, query })
+        if (loadVersion !== _pageLoadVersion) return
         if (data !== undefined && data !== null) {
           loaderData = data
-          // Make loader data available via usePageData() for this navigation.
-          ;(globalThis).__CER_DATA__ = data
+          hasFreshLoaderData = true
         }
       } catch (err) {
+        if (loadVersion !== _pageLoadVersion) return
         // Loader errors are surfaced through currentError so the error boundary
         // (app/error.ts) can display a meaningful message — consistent with how
         // the server-side handler behaves when a loader throws.
@@ -118,11 +132,21 @@ async function _loadPageForPath(path, options = {}) {
     // loader payload in globalThis.__CER_DATA__ / window.__CER_DATA__. Reuse it
     // instead of re-running the loader on the client, then derive primitive attrs
     // from that payload so useProps() stays consistent with usePageData().
+    if (loadVersion !== _pageLoadVersion) return
     loaderAttrs = { ...loaderAttrs, ..._toLoaderAttrs(loaderData) }
+    if (hasFreshLoaderData) {
+      // Publish loader data only after confirming this is still the newest route.
+      ;(globalThis).__CER_DATA__ = loaderData
+    }
+    _currentPageTag = mod.default ?? null
+    _currentPagePath = url.pathname
     _currentPageAttrs = loaderAttrs
+    _currentPageKey = loadVersion
   } catch {
+    if (loadVersion !== _pageLoadVersion) return
     _currentPageTag = null
     _currentPageAttrs = {}
+    _currentPageKey = null
     _currentPagePath = null
   }
 }
@@ -140,9 +164,15 @@ const resetError = () => {
 
 const _push = router.push.bind(router)
 const _replace = router.replace.bind(router)
+// Captures navigation intent synchronously, before route imports resolve or the
+// History API changes the visible URL. Hydration uses this to avoid restoring a
+// stale entry page over an already-requested navigation.
+let _navigationIntent = 0
 
 router.push = async (path) => {
+  const navigationIntent = ++_navigationIntent
   isNavigating.value = true
+  _activateClientRouteRendering()
   currentError.value = null
   try {
     // Clear stale loader data from the previous route before loading the new one.
@@ -150,29 +180,92 @@ router.push = async (path) => {
     // correctly returns null instead of leaking the previous page's data.
     delete (globalThis).__CER_DATA__
     await _loadPageForPath(path)
+    if (navigationIntent !== _navigationIntent) return
     await _push(path)
   } catch (err) {
     currentError.value = err instanceof Error ? err.message : String(err)
   } finally {
-    isNavigating.value = false
+    if (navigationIntent === _navigationIntent) isNavigating.value = false
   }
 }
 
 router.replace = async (path) => {
+  const navigationIntent = ++_navigationIntent
   isNavigating.value = true
+  _activateClientRouteRendering()
   currentError.value = null
   try {
     // Clear stale loader data from the previous route before loading the new one.
     delete (globalThis).__CER_DATA__
     await _loadPageForPath(path)
+    if (navigationIntent !== _navigationIntent) return
     await _replace(path)
   } catch (err) {
     currentError.value = err instanceof Error ? err.message : String(err)
   } finally {
-    isNavigating.value = false
+    if (navigationIntent === _navigationIntent) isNavigating.value = false
   }
 }
 
+// Make ordinary internal links participate in client-side routing even when
+// their owning custom element has not hydrated yet. The listener runs in the
+// bubble phase so an upgraded component gets first refusal: handlers such as
+// breadcrumbs can call preventDefault() and perform their own navigation.
+// composedPath() is required because document-level delegation cannot otherwise
+// discover an anchor rendered inside a shadow root.
+document.addEventListener('click', (event) => {
+  if (
+    event.defaultPrevented ||
+    event.button !== 0 ||
+    event.metaKey ||
+    event.ctrlKey ||
+    event.shiftKey ||
+    event.altKey
+  ) return
+
+  const anchor = event.composedPath().find(
+    (target) => target instanceof HTMLAnchorElement,
+  )
+  if (!anchor || anchor.hasAttribute('download')) return
+  if (anchor.getAttribute('aria-disabled') === 'true') return
+
+  const target = anchor.getAttribute('target')
+  if (target && target.toLowerCase() !== '_self') return
+
+  const href = anchor.getAttribute('href')
+  if (!href) return
+
+  let url
+  try {
+    url = new URL(href, window.location.href)
+  } catch {
+    return
+  }
+
+  if (
+    (url.protocol !== 'http:' && url.protocol !== 'https:') ||
+    url.origin !== window.location.origin
+  ) return
+
+  const navigationPath = url.pathname + url.search + url.hash
+
+  // Same-page anchors do not need a loader or page-tree replacement. Use the
+  // underlying runtime router so its configured offset, retries, cancellation,
+  // and history state remain consistent with cross-route fragment navigation.
+  if (
+    url.pathname === window.location.pathname &&
+    url.search === window.location.search &&
+    url.hash
+  ) {
+    event.preventDefault()
+    void _push(url.pathname + url.search + url.hash)
+    return
+  }
+
+  event.preventDefault()
+  void router.push(navigationPath)
+})
+
 // ─── Plugins ─────────────────────────────────────────────────────────────────
 
 // Collect plugin-provided values so cer-layout-view can forward them into
@@ -187,14 +280,30 @@ const _pluginProvides = new Map()
 
 // ─── <cer-layout-view> ───────────────────────────────────────────────────────
 
-// True until the initial page module has loaded and _replace has been called.
-// While true, cer-layout-view renders a <slot> so the SSR/SSG pre-rendered
-// light-DOM content stays visible and no FOUC occurs during the hydration gap.
+// True while the upgraded SSR/SSG light DOM is the live application. The slot
+// stays active after initial route setup so the framework does not construct a
+// second, duplicate component tree. The first real navigation switches to the
+// client-rendered route tree and releases the server DOM.
 // Declared here (before component()) because customElements.define() upgrades
 // existing DOM elements synchronously, so the render function reads this ref
 // on the very first call — before _doHydrate has a chance to run.
 const _cerHydrating = ref(true)
 
+function _activateClientRouteRendering() {
+  if (!_cerHydrating.value) return
+  _cerHydrating.value = false
+
+  // The initial SSR tree lives in cer-layout-view's light DOM. Once its slot is
+  // no longer used, disconnect it so hidden components, listeners, and reactive
+  // state do not remain retained for the lifetime of the application. Queue the
+  // cleanup after the reactive render requested above so navigation never
+  // exposes a momentarily empty view.
+  const host = document.querySelector('cer-layout-view')
+  if (host?.childNodes.length) {
+    queueMicrotask(() => host.replaceChildren())
+  }
+}
+
 component('cer-layout-view', () => {
   // Forward plugin-provided values into the component context so inject() in
   // any descendant component can resolve them by walking up the DOM tree.
@@ -210,13 +319,9 @@ component('cer-layout-view', () => {
     // store.subscribe() synchronously pushes the current route once on
     // subscription. That initial callback is not a real navigation and must not
     // tear down the SSR slot before _doHydrate has pre-loaded the page.
-    // Subsequent callbacks may be real navigations, but initRouter() also fires
-    // a queueMicrotask(() => navigate(...)) to run guards on the entry URL.
-    // That startup microtask resolves during the await route.load() gap —
-    // before _currentPageTag is set — so we must not drop the slot until the
-    // page module has actually been loaded (_currentPageTag !== null).
-    // The explicit _cerHydrating.value = false in _doHydrate() fires after
-    // _loadPageForPath completes and is the authoritative hydration trigger.
+    // Later state pushes update the stored route, but the SSR slot is released
+    // only by the wrapped push/replace methods on a real client navigation.
+    // initRouter's startup guard replay therefore cannot duplicate the tree.
     unsub = router.subscribe((s) => {
       const _isInitialSubscribePush = !_sawInitialRouteState
       _sawInitialRouteState = true
@@ -224,7 +329,6 @@ component('cer-layout-view', () => {
         current.value = s
         return
       }
-      if (_cerHydrating.value && _currentPageTag !== null) _cerHydrating.value = false
       current.value = s
     })
   })
@@ -264,7 +368,7 @@ component('cer-layout-view', () => {
   // is rendered without stale pre-loaded state.
   const _useDirectRender = _currentPageTag && _currentPagePath === current.value.path
   const pageVnode = _useDirectRender
-    ? { tag: _currentPageTag, props: { attrs: _currentPageAttrs }, children: [] }
+    ? { tag: _currentPageTag, key: _currentPageKey, props: { attrs: _currentPageAttrs }, children: [] }
     : { tag: 'router-view', props: {}, children: [] }
 
   // Support nested layout chains: meta.layoutChain = ['default', 'admin']
@@ -307,36 +411,102 @@ for (const plugin of plugins) {
 if (typeof window !== 'undefined') {
   const _initMatch = router.matchRoute(window.location.pathname)
   const _hydrateStrategy = _initMatch?.route?.meta?.hydrate ?? 'load'
+  const _entryHost = document.querySelector('cer-layout-view')
+  const _entryHasServerTree = Boolean(_entryHost && Array.from(_entryHost.childNodes).some(
+    (node) => node.nodeType === 1 || Boolean(node.textContent?.trim()),
+  ))
+  const _entryServerTreePath = _entryHost?.getAttribute('data-cer-route')
+  const _entryServerTreeMatches = !_entryServerTreePath ||
+    decodeURIComponent(_entryServerTreePath) === window.location.pathname
+  const _canKeepStaticEntry = _entryHasServerTree && _entryServerTreeMatches
+
+  if (_hydrateStrategy === 'none' && _canKeepStaticEntry) {
+    // Matching static HTML only — leave the page output and loader data
+    // untouched. Load its module after the first paint so explicitly
+    // interactive descendants (breadcrumbs, TOCs, menus, etc.) can upgrade
+    // without putting the static page chunk on the critical rendering path.
+    const _loadStaticRouteModule = () => {
+      const _load = _initMatch?.route?.load
+      if (typeof _load === 'function') {
+        void _load().catch((error) => {
+          console.error('[cer-app] Failed to activate static route islands:', error)
+        })
+      }
+    }
+    if (typeof requestAnimationFrame === 'function') {
+      requestAnimationFrame(() => setTimeout(_loadStaticRouteModule, 0))
+    } else {
+      setTimeout(_loadStaticRouteModule, 0)
+    }
 
-  if (_hydrateStrategy === 'none') {
-    // Static HTML only — leave SSR output untouched, clean up data immediately.
-    delete (globalThis).__CER_DATA__
+    // The server marks the page host with data-cer-hydrate="none", so upgrading
+    // its custom element cannot trigger a second render.  Keep __CER_DATA__
+    // available for nested static components as they upgrade; the first
+    // real client navigation clears it before rendering the destination route.
+    // A static host may serve another entry's HTML as its history fallback;
+    // that mismatched tree must go through normal client route activation.
   } else {
     const _doHydrate = async () => {
+      const _hydrationIntent = _navigationIntent
       const _initPath = window.location.pathname + window.location.search + window.location.hash
+      const _hasInitialServerTree = _entryHasServerTree
+      const _serverTreePath = _entryServerTreePath
+      const _serverTreeMatchesEntry = !_serverTreePath ||
+        decodeURIComponent(_serverTreePath) === new URL(_initPath, window.location.origin).pathname
       const _hasInitialLoaderData = Object.prototype.hasOwnProperty.call(globalThis, '__CER_DATA__')
       // Pre-load the page module and run the loader so cer-layout-view renders
       // the page tag directly with loader attrs (enables useProps() on hydration).
-      await _loadPageForPath(
-        _initPath,
-        _hasInitialLoaderData
-          ? { runLoader: false, initialData: (globalThis).__CER_DATA__ }
-          : undefined,
-      )
+      if (_hydrationIntent === 0) {
+        await _loadPageForPath(
+          _initPath,
+          _hasInitialLoaderData && _serverTreeMatchesEntry
+            ? { runLoader: false, initialData: (globalThis).__CER_DATA__ }
+            : undefined,
+        )
+      }
       // Only activate the initial route if the URL hasn't changed while we were
       // loading the module asynchronously (e.g. a test or plugin navigated away
       // before _doHydrate finished).  Calling _replace with a stale path would
       // override any navigation that happened during the async gap.
       const _currentPath = window.location.pathname + window.location.search + window.location.hash
-      // Drop the hydration slot cover unconditionally: the page module is loaded
-      // and cer-layout-view must switch from the <slot> to live rendering whether
-      // or not a redirect changed the path during loading.
-      _cerHydrating.value = false
-      if (_currentPath === _initPath) {
+      if (
+        _navigationIntent === _hydrationIntent &&
+        _currentPath === _initPath
+      ) {
         // Use the original (unwrapped) replace so isNavigating stays false during
         // the initial paint — the loading component must not flash over pre-rendered content.
         await _replace(_initPath)
       }
+
+      // An empty SPA shell has no server tree to retain. Middleware may also
+      // redirect either while the initial chunk loads or while _replace runs,
+      // making the SSR tree stale. This decision deliberately lives outside
+      // the URL-stability guard above: a newer URL must not be overwritten, but
+      // its resolved route still needs to replace the old server-rendered tree.
+      const _requestedInitialPath = new URL(_initPath, window.location.origin).pathname
+      const _resolvedInitialPath = router.getCurrent().path
+      const _urlLeftInitialEntry = _currentPath !== _initPath
+      if (
+        !_hasInitialServerTree ||
+        !_serverTreeMatchesEntry ||
+        _urlLeftInitialEntry ||
+        _resolvedInitialPath !== _requestedInitialPath
+      ) {
+        if (
+          !_serverTreeMatchesEntry ||
+          _urlLeftInitialEntry ||
+          _resolvedInitialPath !== _requestedInitialPath
+        ) {
+          delete (globalThis).__CER_DATA__
+        }
+        if (
+          _navigationIntent === _hydrationIntent &&
+          _currentPagePath !== _resolvedInitialPath
+        ) {
+          await _loadPageForPath(_resolvedInitialPath)
+        }
+        _activateClientRouteRendering()
+      }
       // The client entry marks the already-rendered entry URL so generated
       // route middleware can skip the browser router's startup replay once.
       // Clear any leftover flag after the first hydrated route commits so later

package/dist/runtime/app-template.js.map

@@ -1 +1 @@
-{"version":3,"file":"app-template.js","sourceRoot":"","sources":["../../src/runtime/app-template.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB;IACtC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+WR,CAAA;AACD,CAAC"}
+{"version":3,"file":"app-template.js","sourceRoot":"","sources":["../../src/runtime/app-template.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CAAC,gBAAmC,EAAE;IAC5E,MAAM,kBAAkB,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,aAAa,CAAC,CAAC;SACnD,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,WAAW,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC;SACvF,IAAI,CAAC,IAAI,CAAC,CAAA;IACb,OAAO;;;;EAIP,kBAAkB,GAAG,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkhBpD,CAAA;AACD,CAAC"}

package/dist/runtime/composables/index.d.ts

@@ -25,4 +25,8 @@ export type { LocaleComposable } from './use-locale.js';
 export { queryContent, QueryBuilder } from './use-content.js';
 export { useContentSearch } from './use-content-search.js';
 export type { UseContentSearchReturn } from './use-content-search.js';
+export { defineContentPageLoader, normalizeContentPath, useContentBreadcrumbs, useContentHeadings, useContentSeo, } from './use-content-page.js';
+export type { ContentBreadcrumb, ContentBreadcrumbOptions, ContentPageData, ContentPageLoaderOptions, ContentSeoOptions, } from './use-content-page.js';
+export { useActiveHeadings } from './use-active-headings.js';
+export type { ActiveHeadingsOptions } from './use-active-headings.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/composables/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/composables/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAClG,YAAY,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AACnG,YAAY,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAC7G,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAA;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,YAAY,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACzE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACvC,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAC7D,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAC7G,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC1D,YAAY,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/composables/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAClG,YAAY,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AACnG,YAAY,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAC7G,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAA;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,YAAY,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACzE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACvC,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAC7D,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAC7G,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC1D,YAAY,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAA;AACrE,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,aAAa,GACd,MAAM,uBAAuB,CAAA;AAC9B,YAAY,EACV,iBAAiB,EACjB,wBAAwB,EACxB,eAAe,EACf,wBAAwB,EACxB,iBAAiB,GAClB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC5D,YAAY,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAA"}

package/dist/runtime/composables/index.js

@@ -15,4 +15,6 @@ export { useState } from './use-state.js';
 export { useLocale } from './use-locale.js';
 export { queryContent, QueryBuilder } from './use-content.js';
 export { useContentSearch } from './use-content-search.js';
+export { defineContentPageLoader, normalizeContentPath, useContentBreadcrumbs, useContentHeadings, useContentSeo, } from './use-content-page.js';
+export { useActiveHeadings } from './use-active-headings.js';
 //# sourceMappingURL=index.js.map

package/dist/runtime/composables/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/composables/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAElG,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAEnG,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAA;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAE9C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAEzC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAEzC,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/composables/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAElG,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAEnG,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAA;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAE9C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAEzC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAEzC,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAE1D,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,aAAa,GACd,MAAM,uBAAuB,CAAA;AAQ9B,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA"}

package/dist/runtime/composables/use-active-headings.d.ts

@@ -0,0 +1,24 @@
+import type { ContentHeading } from '../../types/content.js';
+type HeadingSource = readonly ContentHeading[] | {
+    value: readonly ContentHeading[];
+};
+export interface ActiveHeadingsOptions {
+    /** DOM root containing the rendered headings. Defaults to document. */
+    root?: ParentNode | (() => ParentNode | null);
+    /** Sticky-header offset in pixels. Defaults to 0. */
+    offset?: number;
+    /** IntersectionObserver root, when observing inside a scroll container. */
+    observerRoot?: Element | null;
+    /** Override the observer margin. */
+    rootMargin?: string;
+}
+/**
+ * Tracks visible content headings with one IntersectionObserver. This avoids
+ * scroll-event layout reads and works with document, light-DOM, and shadow roots.
+ */
+export declare function useActiveHeadings(source: HeadingSource, options?: ActiveHeadingsOptions): {
+    activeIds: any;
+    isActive: (id: string) => any;
+};
+export {};
+//# sourceMappingURL=use-active-headings.d.ts.map

package/dist/runtime/composables/use-active-headings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-active-headings.d.ts","sourceRoot":"","sources":["../../../src/runtime/composables/use-active-headings.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAE5D,KAAK,aAAa,GAAG,SAAS,cAAc,EAAE,GAAG;IAAE,KAAK,EAAE,SAAS,cAAc,EAAE,CAAA;CAAE,CAAA;AAErF,MAAM,WAAW,qBAAqB;IACpC,uEAAuE;IACvE,IAAI,CAAC,EAAE,UAAU,GAAG,CAAC,MAAM,UAAU,GAAG,IAAI,CAAC,CAAA;IAC7C,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,2EAA2E;IAC3E,YAAY,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;IAC7B,oCAAoC;IACpC,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAiBD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,GAAE,qBAA0B;;mBA2FzE,MAAM;EAExB"}

package/dist/runtime/composables/use-active-headings.js

@@ -0,0 +1,112 @@
+import { nextTick, ref, useOnConnected, watch } from '@jasonshimmy/custom-elements-runtime';
+function sourceValue(source) {
+    return Array.isArray(source)
+        ? source
+        : source.value;
+}
+function resolveRoot(root) {
+    if (typeof root === 'function')
+        return root();
+    return root ?? (typeof document !== 'undefined' ? document : null);
+}
+function escapeAttribute(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+/**
+ * Tracks visible content headings with one IntersectionObserver. This avoids
+ * scroll-event layout reads and works with document, light-DOM, and shadow roots.
+ */
+export function useActiveHeadings(source, options = {}) {
+    const activeIds = ref([]);
+    const intersecting = new Set();
+    const headingTops = new Map();
+    useOnConnected(() => {
+        let observer = null;
+        let observationRevision = 0;
+        let disposed = false;
+        const observe = () => {
+            observer?.disconnect();
+            intersecting.clear();
+            headingTops.clear();
+            activeIds.value = [];
+            const headings = sourceValue(source);
+            const root = resolveRoot(options.root);
+            if (!root || headings.length === 0)
+                return;
+            // Establish a useful state immediately. IntersectionObserver callbacks
+            // are asynchronous, and on an entry navigation every heading may begin
+            // below the narrowed activation band even though the first section is
+            // the section the reader is approaching.
+            activeIds.value = [headings[0].id];
+            if (typeof IntersectionObserver === 'undefined') {
+                return;
+            }
+            observer = new IntersectionObserver((entries) => {
+                for (const entry of entries) {
+                    const id = entry.target.id;
+                    if (!id)
+                        continue;
+                    const top = entry.boundingClientRect?.top;
+                    if (Number.isFinite(top))
+                        headingTops.set(id, top);
+                    if (entry.isIntersecting)
+                        intersecting.add(id);
+                    else
+                        intersecting.delete(id);
+                }
+                const orderedIds = sourceValue(source).map((heading) => heading.id);
+                const visibleIds = orderedIds.filter((id) => intersecting.has(id));
+                if (visibleIds.length > 0) {
+                    activeIds.value = visibleIds;
+                    return;
+                }
+                // When the activation band lies in the gap between headings, keep the
+                // most recently passed section selected. At the top of the article,
+                // where no heading has crossed the sticky-header line, select the first
+                // section instead of presenting an unexplained empty state.
+                const activationTop = options.offset ?? 0;
+                let fallback = orderedIds[0];
+                for (const id of orderedIds) {
+                    const top = headingTops.get(id);
+                    if (top !== undefined && top <= activationTop)
+                        fallback = id;
+                }
+                activeIds.value = fallback ? [fallback] : [];
+            }, {
+                root: options.observerRoot ?? null,
+                rootMargin: options.rootMargin ?? `-${options.offset ?? 0}px 0px -60% 0px`,
+                threshold: [0, 1],
+            });
+            for (const heading of headings) {
+                const element = root.querySelector(`[id="${escapeAttribute(heading.id)}"]`);
+                if (element)
+                    observer.observe(element);
+            }
+        };
+        const scheduleObserve = () => {
+            const revision = ++observationRevision;
+            // A child receives its new heading props while the parent page is still
+            // being patched. Waiting for the runtime's DOM queue prevents querying
+            // the outgoing article and permanently observing stale heading nodes.
+            void nextTick().then(() => {
+                if (!disposed && revision === observationRevision)
+                    observe();
+            });
+        };
+        scheduleObserve();
+        const stop = watch(() => sourceValue(source), scheduleObserve);
+        return () => {
+            disposed = true;
+            observationRevision += 1;
+            stop?.();
+            observer?.disconnect();
+            intersecting.clear();
+            headingTops.clear();
+        };
+    });
+    return {
+        activeIds,
+        isActive: (id) => activeIds.value.includes(id),
+    };
+}
+//# sourceMappingURL=use-active-headings.js.map

package/dist/runtime/composables/use-active-headings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-active-headings.js","sourceRoot":"","sources":["../../../src/runtime/composables/use-active-headings.ts"],"names":[],"mappings":"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"}

package/dist/runtime/composables/use-content-page.d.ts

@@ -0,0 +1,45 @@
+import type { ContentHeading, ContentItem } from '../../types/content.js';
+import type { PageLoaderContext } from '../../types/page.js';
+export interface ContentPageData {
+    doc: ContentItem | null;
+    existingPaths: string[];
+}
+export interface ContentBreadcrumb {
+    label: string;
+    path: string;
+    icon: string;
+    key: string;
+    isLast: boolean;
+    hasPage: boolean;
+}
+export interface ContentBreadcrumbOptions {
+    rootLabel?: string;
+    rootIcon?: string;
+    formatLabel?: (segment: string) => string;
+}
+export interface ContentPageLoaderOptions {
+    /** Catch-all route parameter name. Defaults to `all`. */
+    param?: string;
+}
+export interface ContentSeoOptions {
+    doc: ContentItem | null;
+    path: string;
+    siteUrl: string;
+    siteName?: string;
+    image?: string;
+    breadcrumbs?: ContentBreadcrumb[];
+    /** Path depth at which Open Graph pages become articles. Defaults to 2. */
+    articleDepth?: number;
+    notFoundTitle?: string;
+}
+/** Normalize a route/catch-all value into the content layer's absolute path form. */
+export declare function normalizeContentPath(value: string | undefined | null): string;
+/** Create a catch-all content loader with document and ancestor-page data. */
+export declare function defineContentPageLoader(options?: ContentPageLoaderOptions): ({ params }: PageLoaderContext) => Promise<ContentPageData>;
+/** Build accessible breadcrumb data from a content path and known ancestor pages. */
+export declare function useContentBreadcrumbs(path: string, doc: ContentItem | null, existingPaths?: readonly string[], options?: ContentBreadcrumbOptions): ContentBreadcrumb[];
+/** Return the document headings appropriate for a table of contents. */
+export declare function useContentHeadings(doc: Pick<ContentItem, 'toc'> | null | undefined, depths?: readonly ContentHeading['depth'][]): ContentHeading[];
+/** Apply consistent content title, canonical, social, robots, and JSON-LD metadata. */
+export declare function useContentSeo(options: ContentSeoOptions): void;
+//# sourceMappingURL=use-content-page.d.ts.map