@uniweb/runtime 1.2.9 → 1.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/runtime",
-  "version": "1.2.9",
+  "version": "1.2.11",
   "description": "Minimal runtime for loading Uniweb foundations",
   "type": "module",
   "exports": {

package/src/font-links.js

@@ -0,0 +1,23 @@
+import { FONT_LINKS_MARKER } from '@uniweb/theming'
+
+/**
+ * Give a page the theme's font links when it arrived without them.
+ *
+ * A built page carries them in its `<head>` (`@uniweb/build`), and so does a prerendered
+ * one (`injectPageContent` in `ssr-renderer.js`). A host that serves the shell alone and
+ * leaves every page to the browser carries neither. `ensureThemeCss` computes the links
+ * onto the graph for such a lane, but nothing put them on the page: the browser added the
+ * theme's CSS (`ThemeProvider`) and never its fonts, so every family the theme imports
+ * fell back to a system face. This is the browser's half of the prerender's font block,
+ * deduped on the same marker, so a page that already has them is left alone.
+ *
+ * @param {object} themeData - `website.themeData`, with the `links` block `@uniweb/theming` generated
+ * @param {Document|null} [doc]
+ * @returns {boolean} whether it added them
+ */
+export function injectFontLinks(themeData, doc = typeof document === 'undefined' ? null : document) {
+  const head = doc?.head
+  if (!head || !themeData?.links || head.innerHTML.includes(FONT_LINKS_MARKER)) return false
+  head.insertAdjacentHTML('beforeend', `${FONT_LINKS_MARKER}\n${themeData.links}`)
+  return true
+}

package/src/hooks/useLinkInterceptor.js

@@ -110,7 +110,8 @@ export function inAppLink(anchor) {
 
 /**
  * Whether a page of `website` can have something to fetch before it is shown: content not here
- * yet, on a site whose content is split, or data, which a site declaring queries reads.
+ * yet, on a site whose content is split, or data a page declares where it can be seen
+ * (`readsData`).
  */
 function hasPagesToFetch(website) {
   if (readsData(website)) return true

package/src/link-intent.js

@@ -2,9 +2,9 @@
  * Prefetch on intent: a link's page is fetched while the reader is about to follow it.
  *
  * Only a site with something to fetch before a page is shown loads this module
- * (`useLinkInterceptor`): split content not here yet, or data, which a site declaring queries
- * reads. A site with neither never downloads it, so the runtime every site carries pays only for
- * the decision.
+ * (`useLinkInterceptor`): split content not here yet, or data a page declares where it can be seen
+ * (`readsData`, `navigation.js`). A site with neither never downloads it, so the runtime every site
+ * carries pays only for the decision.
  *
  * A pointer resting on a link, or focus staying on one, for INTENT_DELAY fetches what the page
  * the link goes to will read: its split content, then its sections' data, whatever is not held

package/src/navigation.js

@@ -80,29 +80,47 @@ function isReady(page) {
 }
 
 /**
- * Whether the site declares a query. Data comes from a named query (`config.queries`), so a site
- * that declares none reads none, and its pages are not walked for it.
+ * Whether a fetch can be seen reaching `page` without building its sections: the site declares
+ * queries (`config.queries`), or a fetch sits on the page, its parent page or the site, or the page
+ * is parametric and asks for its own record. A section's own `fetch:` is read only once its block is
+ * built, so a page whose data is declared on its sections alone is not seen here.
+ *
+ * ⛔ `config.queries` alone is not the test. A hosted site's schema-less query is not projected
+ * there: its fetch carries the file's `path` (measured 2026-10-27 on a site's blog: no
+ * `config.queries`, the page's fetch `{ query, path, as }`). A gate on it skipped that blog's data.
+ *
+ * @param {Object} page
+ * @returns {boolean}
+ */
+function declaresData(page) {
+  const config = page.website?.config
+  const queries = config?.queries
+  if (queries && typeof queries === 'object' && Object.keys(queries).length > 0) return true
+  return !!(page.fetch || page.parent?.fetch || config?.fetch || page.dynamicContext)
+}
+
+/**
+ * Whether a page of `website` declares data where it can be seen without building sections (see
+ * `declaresData`): what decides whether prefetching on intent is worth its module.
  *
  * @param {Object|null|undefined} website
  * @returns {boolean}
  */
 export function readsData(website) {
-  const queries = website?.config?.queries
-  return !!queries && typeof queries === 'object' && Object.keys(queries).length > 0
+  return !!website?.pages?.some((page) => declaresData(page))
 }
 
 /**
  * Ask what `page`'s render will read and the cache does not hold: off a parametric page, the
  * page's own record, which names it; and each block's data, by the same call the renderer makes
- * after mount (`EntityStore.fetch`).
+ * after mount (`EntityStore.fetch`). It builds the page's blocks, which its render is about to do.
  *
  * @param {Object} page - its content here
  * @returns {Promise|undefined} undefined when nothing was asked
  */
 function dataOf(page) {
-  const website = page.website
-  const store = website?.entityStore
-  if (!store || !readsData(website)) return
+  const store = page.website?.entityStore
+  if (!store) return
   const asks = []
   if (page.dynamicContext) asks.push(store.fetchPageRecord(page))
   for (const block of blocksOf(page)) {
@@ -116,13 +134,19 @@ function dataOf(page) {
  * The wait for what `page`'s render reads and is not here yet: its split content, then, its
  * sections known, their data.
  *
+ * ⚖️ A navigation asks for the data of every page it goes to, since building the blocks is work its
+ * render does a moment later. A prefetch is a guess the reader may not follow, so it asks only where
+ * data can be seen reaching the page (`declaresData`), and leaves sections unbuilt elsewhere.
+ *
  * @param {Object|null} page
+ * @param {{ speculative?: boolean }} [options]
  * @returns {Promise|undefined} undefined when it is all here
  */
-function loadPage(page) {
+function loadPage(page, { speculative = false } = {}) {
   if (!page) return
-  if (!isReady(page)) return page.loadContent().then(() => dataOf(page))
-  return dataOf(page)
+  const data = () => (speculative && !declaresData(page) ? undefined : dataOf(page))
+  if (!isReady(page)) return page.loadContent().then(data)
+  return data()
 }
 
 /** `wait`, or the end of HOLD_TIMEOUT, whichever comes first. */
@@ -152,7 +176,7 @@ export function prefetchContent(route) {
  * @returns {Promise|undefined} undefined when it is all here
  */
 export function prefetchPage(route) {
-  return loadPage(pageAt(route))?.catch(() => {})
+  return loadPage(pageAt(route), { speculative: true })?.catch(() => {})
 }
 
 // The navigation the next swap belongs to. A later navigation supersedes one still waiting for

package/src/setup.js

@@ -31,6 +31,7 @@ import {
 import { ChildBlocks } from './components/PageRenderer.jsx'
 import Background from './components/Background.jsx'
 import { wireFoundationCapabilities, hydrateDataStore, ensureThemeCss } from './wire-foundation.js'
+import { injectFontLinks } from './font-links.js'
 import { navigateInApp } from './navigation.js'
 
 // Re-export so existing consumers importing hydrateDataStore from
@@ -274,6 +275,9 @@ export function initUniweb({ content, foundation, extensions = [], routingCompon
   if (typeof document === 'undefined' || !document.getElementById('uniweb-theme')) {
     ensureThemeCss(uniweb, foundation)
   }
+  // And the theme's font links, which the CSS alone does not bring: a page that came
+  // with neither would otherwise set every imported family in a system face.
+  injectFontLinks(uniweb.activeWebsite?.themeData)
 
   uniweb.routingComponents = routingComponents
   uniweb.localeSwitch = localeSwitch