@symbo.ls/brender 3.14.663 → 3.14.665

package/prefetch.js

@@ -1,12 +1,13 @@
 /**
  * SSR data prefetching for brender.
  *
- * Walks a page definition tree, collects `fetch` declarations,
- * executes them against the configured DB adapter,
- * and returns the fetched data keyed by element path + `as` field.
+ * `fetchSSRTranslations` loads a project's table/RPC labels before a render.
  *
- * This allows brender to inject fetched data into element state
- * before rendering, so the SSR output matches the client-side SPA.
+ * `prefetchPageData` walks a page definition tree, collects `fetch`
+ * declarations, executes them against the configured DB adapter, and returns
+ * the fetched data keyed by element path + `as` field. render() does NOT use
+ * it: the fetch plugin loads a page's data during the render, with the real
+ * element (a `transform` here gets no element). Kept for direct callers.
  */
 
 const isFunction = (v) => typeof v === 'function'
@@ -192,6 +193,10 @@ const executeSingle = async (adapter, config) => {
 /**
  * Prefetch all data for a page route.
  *
+ * @deprecated render() and renderPage() no longer use it: the fetch plugin
+ * loads a page's data during the render, with the real element (a `transform`
+ * here gets none). The `prefetch` render option does not call it. Kept for
+ * direct callers; to be removed.
  * @param {object} data - Full project data (from loadProject)
  * @param {string} route - Route to prefetch for (e.g. '/', '/blog')
  * @param {object} [options]
@@ -235,13 +240,6 @@ export const prefetchPageData = async (data, route = '/', options = {}) => {
   return stateUpdates
 }
 
-/**
- * Inject prefetched data into a page definition's state objects.
- * Mutates the definition in place (caller should deep-clone first).
- *
- * @param {object} pageDef - Page definition (will be mutated)
- * @param {Map<string, object>} stateUpdates - Map from prefetchPageData
- */
 /**
  * Fetch polyglot translations from the DB for SSR use.
  * Returns a map of { [lang]: { key: text, ... } } for all configured languages.
@@ -254,6 +252,14 @@ export const fetchSSRTranslations = async (data) => {
   const config = data.config || {}
   const polyglot = config.polyglot || data.polyglot
   if (!polyglot?.fetch) return null
+  // A FUNCTION is the project's own loader — `(lang, version, el) => …`,
+  // called by the polyglot plugin. It runs inside the render, with the real
+  // root element (its el.call / el.getDB), and render() reads its labels back
+  // from the root state. This used to fall through to the RPC branch below
+  // with brender's default name, `get_translations_if_changed`: one request
+  // per language per route that the project never serves — 44 answered 404
+  // in one build (xma.info report, brender build item 11).
+  if (typeof polyglot.fetch === 'function') return null
 
   const dbConfig = config.fetch || data.fetch || config.db || data.db
   if (!dbConfig) return null
@@ -291,53 +297,19 @@ export const fetchSSRTranslations = async (data) => {
 }
 
 /**
- * Pre-evaluate children functions and replace them with static results.
- * During SSR, DOMQL's runtime state cascading and async re-render cycle
- * may not work correctly (trackSourcemapDeep stack overflows, etc.).
- * By pre-evaluating the children functions, we produce static element
- * definitions that DOMQL can render directly.
+ * Merge prefetched data into a page definition's element states. Mutates the
+ * definition in place (the caller deep-clones first).
+ *
+ * @deprecated render() no longer uses it (the fetch plugin loads a page's data
+ * during the render); kept for callers of prefetchPageData, to be removed.
+ *
+ * It used to go on and evaluate every `children` FUNCTION under the target
+ * with a stand-in element — whose call() answered 'ka' for any language and
+ * returned the enclosing arrow function's `arguments[1]` for a label — and
+ * freeze the result into a static array the real data could never replace
+ * (xma.info report, brender build items 5 and 13). A children function stays
+ * a function now: the render runs it with the real element.
  */
-const preEvaluateChildren = (def, inheritedState) => {
-  if (!def || typeof def !== 'object') return
-  for (const key in def) {
-    if (key === 'state' || key === 'fetch' || key === 'props' ||
-        key === 'attr' || key === 'on' || key === 'define' ||
-        key === 'childExtends' || key === 'childProps' || key === 'childrenAs') continue
-    if (key.charAt(0) >= 'A' && key.charAt(0) <= 'Z' && isObject(def[key])) {
-      const child = def[key]
-      // Determine effective state for this element (own state or inherited)
-      const effectiveState = child.state && typeof child.state === 'object'
-        ? { ...inheritedState, ...child.state }
-        : inheritedState
-
-      // Pre-evaluate children function
-      if (isFunction(child.children)) {
-        try {
-          const mockEl = {
-            state: effectiveState,
-                call: (fn) => {
-              if (fn === 'getActiveLang' || fn === 'getLang') return effectiveState?.lang || 'ka'
-              if (fn === 'polyglot') return arguments[1] || ''
-              return undefined
-            },
-            __ref: {}
-          }
-          const result = child.children(mockEl, effectiveState)
-          if (isArray(result) && result.length > 0) {
-            // Replace children function with static array
-            child.children = result
-          }
-        } catch {
-          // If evaluation fails, leave the function as-is
-        }
-      }
-
-      // Recurse deeper
-      preEvaluateChildren(child, effectiveState)
-    }
-  }
-}
-
 export const injectPrefetchedState = (pageDef, stateUpdates) => {
   if (!stateUpdates || !stateUpdates.size) return
 
@@ -358,10 +330,6 @@ export const injectPrefetchedState = (pageDef, stateUpdates) => {
         target.state = {}
       }
       Object.assign(target.state, data)
-
-      // Pre-evaluate children functions with the injected state
-      // so DOMQL gets static element definitions instead of functions
-      preEvaluateChildren(target, target.state)
     }
   }
 }