@koehler8/cms 1.4.0 → 1.4.1

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 1.4.1
+
+### Fixed
+
+- **The embedded config payload is now actually used on locale-prefixed routes.**
+  vite-ssg runs the setup fn *before* `app.use(router)`, so `router.currentRoute`
+  is still `START_LOCATION` (`'/'`, `params: {}`) there — identically on every
+  page. During SSG that was already handled, because vite-ssg hands the route
+  over on `ctx.routePath`. On the **client** it calls the setup fn with no
+  argument at all, so there was nothing to resolve and the code fell through to
+  `START_LOCATION`.
+
+  `loadSiteConfig` derives its cache key from `params.locale`, so the key came
+  out `'default'` on every client page while the SSG had stamped the real locale
+  on `siteConfigLocale`. On a locale-prefixed route the two never matched, so
+  `primeConfigSync` was skipped, `hydrateFromSyncCache` missed, and the client
+  discarded the payload it had just been served and awaited a full config load
+  **inside the setup fn, on the critical path, before mount** — the exact
+  regression the priming machinery exists to prevent.
+
+  Measured on a multi-locale site, same machine and build, only this patch
+  differing. First config chunk on a `/th/` piece page: **44 ms before**
+  (DOMContentLoaded 34 ms — on the critical path), **1364 ms after** (deferred
+  to `requestIdleCallback`, as designed). The load is *deferred, not removed*:
+  `trimConfigToPage` stamps `pagesPartial` on every page, so the idle reload
+  still runs.
+
+  ⚠️ A cross-environment comparison hides this completely. A production bundle
+  that needs ~1.4 s to download and execute shows its config chunks at ~1607 ms,
+  which *looks* deferred when it is in fact immediate. Only a same-environment
+  A/B separates the two.
+
+  **No action needed in a site.** Single-locale sites already stamped `default`
+  and primed correctly, so their behaviour is unchanged; multi-locale sites gain
+  the deferral.
+
 ## 1.4.0
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koehler8/cms",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "Vertex CMS — lightweight, config-driven Vue 3 framework with theming, extensions, and SSG support",
   "license": "MIT",
   "type": "module",

package/src/main.js

@@ -8,6 +8,7 @@ import { routes, resolveHistory, applyRouterGuards } from './router/index.js';
 import { shouldEnableAnalytics, scheduleAnalyticsLoad, configureAnalyticsConsentMode } from './utils/cookieConsent.js';
 import { loadConfigData, primeConfigSync, trimConfigToPage, resolvePageIdForRoute } from './utils/loadConfig.js';
 import { applyInitialStateTrims } from './utils/initialStateTrim.js';
+import { currentRouteHref } from './utils/currentRoute.js';
 import { persistAttributionFromLocation } from './utils/trackingContext.js';
 import { applyThemeVariables } from './themes/themeManager.js';
 import { setActiveThemeKey } from './utils/themeColors.js';
@@ -136,19 +137,22 @@ export function createCmsApp() {
       };
 
       const extractCurrentRoute = () => {
-        // During SSG, vite-ssg passes the route being pre-rendered as a string
-        // on `ctx.routePath` and only pushes the router AFTER this setup fn runs
-        // — so `router.currentRoute` is still vue-router's START_LOCATION ('/')
-        // here, identically on every page. Resolve `routePath` through the router
-        // (a pure match, no navigation) to recover the real path + `params.locale`.
-        // Without this, `resolveCurrentPageId` sees '/' for every route, so the
-        // payload trim targets the wrong page — or, when '/' is ambiguous, none.
-        const routePath = ctx?.routePath;
-        if (typeof routePath === 'string' && routePath) {
+        // vite-ssg runs this setup fn BEFORE `app.use(router)`, so
+        // `router.currentRoute` is still vue-router's START_LOCATION ('/') here,
+        // identically on every page — during SSG *and* on the client. The href
+        // that IS authoritative differs per half (ctx.routePath vs the window's
+        // own location); currentRouteHref picks it, with the full account of why
+        // the client half is not optional. Resolve it through the router — a pure
+        // match, no navigation — to recover the real path + `params.locale`.
+        const href = currentRouteHref(
+          ctx,
+          typeof window !== 'undefined' ? window.location : null,
+        );
+        if (href) {
           try {
-            return router.resolve(routePath);
+            return router.resolve(href);
           } catch {
-            return { path: routePath, params: {} };
+            return { path: href, params: {} };
           }
         }
         if (ctx?.route) {

package/src/utils/currentRoute.js

@@ -0,0 +1,49 @@
+// Which href the app should resolve through the router to learn the route it is
+// actually on.
+//
+// Both halves of the lifecycle are blind to this in the same way, for the same
+// reason: vite-ssg runs the setup fn BEFORE `app.use(router)`, so
+// `router.currentRoute` is still vue-router's START_LOCATION ('/', `params: {}`)
+// — identically on every page.
+//
+//   - During SSG, vite-ssg hands the route being pre-rendered over as a string on
+//     `ctx.routePath`, so that is authoritative.
+//   - On the CLIENT it calls the setup fn with no argument at all: no
+//     `ctx.routePath`, no `ctx.route`. The only authoritative source left is the
+//     window's own location.
+//
+// Falling through to START_LOCATION on the client is not a cosmetic miss. The
+// config cache key is derived from `params.locale`, so it came out 'default' on
+// every page while the SSG had stamped the real locale on `siteConfigLocale`.
+// The two never matched on a locale-prefixed route, `primeConfigSync` was
+// skipped, and the client discarded the embedded payload and re-fetched the
+// whole config tree on the critical path — the exact regression the priming
+// machinery exists to prevent. Measured on sparkbang.com/th/<piece>/ before the
+// fix: 151 JS requests / 405 KB, 112 of them per-piece config chunks, while the
+// 17 KB embedded payload was parsed and thrown away.
+//
+// Pure and dependency-free so the fall-through can be pinned by a unit test;
+// `main.js` owns the router.resolve() call itself (a pure match, no navigation).
+//
+// Returns null when the caller should use `ctx.route` as-is, or when there is
+// nothing authoritative to resolve and START_LOCATION is genuinely all there is.
+
+/**
+ * @param {{routePath?: unknown, route?: unknown}|null|undefined} ctx
+ *   The vite-ssg setup context. `routePath` is set during SSG only.
+ * @param {{pathname?: unknown, search?: unknown}|null|undefined} location
+ *   `window.location` on the client; omit/null on the server.
+ * @returns {string|null} the href to resolve, or null to fall back.
+ */
+export function currentRouteHref(ctx, location) {
+  const routePath = ctx?.routePath;
+  if (typeof routePath === 'string' && routePath) return routePath;
+  // A context that already carries a resolved route needs no href at all.
+  if (ctx?.route) return null;
+  const pathname = location?.pathname;
+  if (typeof pathname === 'string' && pathname) {
+    const search = typeof location?.search === 'string' ? location.search : '';
+    return `${pathname}${search}`;
+  }
+  return null;
+}