@askrjs/askr 0.3.1 → 0.4.1

package/dist/verify-hydration-D_cyn1OX.js

@@ -0,0 +1,152 @@
+import { r as validateCspNonce } from "./csp-nonce-D-XM_uuJ.js";
+import { g as withHydrationVerificationRender, v as getHydrationRenderUrl } from "./render-context-DGHnEveC.js";
+import { C as removeRouteBasePath, S as normalizeRouteBasePath, f as currentAuth, n as getRouteRenderContext, y as resolveRouteFromRoutes } from "./resolution-CF1BqHLm.js";
+import { t as SSR_RENDER_DATA_ATTR } from "./ssr-DPfdcq0e.js";
+import { i as StringSink, s as createRenderContext, t as renderSSRRouteAppToSink } from "./render-sync-CUxvoVab.js";
+//#region src/ssr/render-resolved.ts
+function sameRouteParams(left, right) {
+	if (!left || !right) return !left && !right;
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	for (const key of leftKeys) if (left[key] !== right[key]) return false;
+	return true;
+}
+/** @internal Render a resolved route handler, with the request-local auth context used by hydration verification. */
+function renderResolvedForHydrationSync(opts, authContext) {
+	const { url, registry, handler, params, options } = opts;
+	const routes = registry.routes;
+	const requestUrl = new URL(url, "http://localhost");
+	const logicalTarget = removeRouteBasePath(`${requestUrl.pathname}${requestUrl.search}${requestUrl.hash}`, normalizeRouteBasePath(registry.manifest.basePath));
+	const matchedIndex = routes.findIndex((route) => {
+		if (logicalTarget === void 0) return false;
+		const resolved = resolveRouteFromRoutes(new URL(logicalTarget, "http://localhost").pathname, [route]);
+		return resolved !== null && resolved.handler === route.handler && sameRouteParams(resolved.params, params ?? {});
+	});
+	if (matchedIndex < 0) throw new Error(`renderResolvedForHydrationSync: no route found for url: ${url}`);
+	const effectiveRoutes = routes.map((route, index) => index === matchedIndex ? {
+		...route,
+		handler
+	} : route);
+	const matchedRoute = routes[matchedIndex];
+	const cspNonce = validateCspNonce(options?.cspNonce);
+	const ctx = createRenderContext(options?.seed, {
+		url,
+		basePath: registry.manifest.basePath,
+		data: options?.data,
+		params,
+		routes: effectiveRoutes,
+		routeAuth: registry.manifest.auth,
+		authContext,
+		dataRuntime: options?.dataRuntime,
+		envelope: options?.envelope,
+		cspNonce
+	});
+	const sink = new StringSink();
+	renderSSRRouteAppToSink({
+		route: {
+			...matchedRoute,
+			handler
+		},
+		params: params ?? {},
+		data: options?.data,
+		ctx,
+		sink
+	});
+	sink.end();
+	return sink.toString();
+}
+//#endregion
+//#region src/ssr/verify-hydration.ts
+const SSR_STYLE_REGISTRY_SELECTOR = "style[data-askr-style-registry]";
+const RENDERER_BOOKKEEPING_ATTRS = [
+	"data-skip-hydrate",
+	"data-key",
+	"data-askr-key-kind"
+];
+/**
+* Parsed declarations in a canonical order. Each parsed longhand is unique, so
+* order carries no meaning here, but the DOM renderer may reorder properties
+* it rewrites.
+*/
+function normalizeStyleDeclarations(style) {
+	const declarations = [];
+	for (let index = 0; index < style.length; index += 1) {
+		const name = style.item(index);
+		const priority = style.getPropertyPriority(name);
+		declarations.push(`${name}: ${style.getPropertyValue(name)}${priority ? ` !${priority}` : ""};`);
+	}
+	return declarations.sort().join(" ");
+}
+/**
+* Serialize markup in a form that is stable across the SSR serializer and the
+* DOM renderer: transport carriers, comments (range anchors) and the
+* key and `data-skip-hydrate` bookkeeping the renderers add are dropped, and style
+* attributes are re-serialized through the CSSOM so `color:red;` and the
+* DOM's `color: red;` compare equal.
+*/
+function normalizeHydrationHtml(html) {
+	const template = document.createElement("template");
+	template.innerHTML = html;
+	for (const carrier of Array.from(template.content.querySelectorAll(`script[${SSR_RENDER_DATA_ATTR}],${SSR_STYLE_REGISTRY_SELECTOR}`))) carrier.remove();
+	for (const name of RENDERER_BOOKKEEPING_ATTRS) for (const element of Array.from(template.content.querySelectorAll(`[${name}]`))) element.removeAttribute(name);
+	for (const element of Array.from(template.content.querySelectorAll("[style]"))) {
+		const style = element.style;
+		if (!style) continue;
+		const cssText = normalizeStyleDeclarations(style);
+		if (cssText) element.setAttribute("style", cssText);
+		else element.removeAttribute("style");
+	}
+	const comments = document.createTreeWalker(template.content, NodeFilter.SHOW_COMMENT);
+	const found = [];
+	while (comments.nextNode()) found.push(comments.currentNode);
+	for (const comment of found) comment.parentNode?.removeChild(comment);
+	return template.innerHTML;
+}
+/**
+* Whether the client renders the same URL the server markup was rendered
+* for. A static page opened with a client-only query or hash is verified
+* against its queryless render URL, then hydration applies the browser URL on
+* purpose, so its client output legitimately differs.
+*/
+function clientRendersServerUrl(url, envelope) {
+	const live = new URL(url, "http://localhost");
+	const renderUrl = getHydrationRenderUrl(envelope);
+	const rendered = new URL(renderUrl ?? live.pathname, "http://localhost");
+	return rendered.search === live.search && rendered.hash === live.hash;
+}
+/**
+* Capture the server markup under `root` before the client renderer touches
+* it, normalized for {@link verifyClientHydrationMarkup}. Returns `null` when
+* the client output is not expected to reproduce it because the page is
+* hydrated at a different URL than it was rendered for.
+*/
+function captureServerHydrationMarkup(root, url, envelope) {
+	const html = root.innerHTML;
+	if (!clientRendersServerUrl(url, envelope)) return null;
+	return normalizeHydrationHtml(html);
+}
+/**
+* Whether client markup left by hydration (`clientHtml`) matches the server
+* markup captured before it ran. Hydration reconciles the server DOM in place,
+* so an SSR/client renderer divergence shows up here even when a fresh server
+* render reproduces the server HTML exactly.
+*/
+function verifyClientHydrationMarkup(clientHtml, serverMarkup) {
+	return normalizeHydrationHtml(clientHtml) === serverMarkup;
+}
+function verifyHydrationSyncForUrl(opts) {
+	const { root, url, registry, resolved, options } = opts;
+	const verificationUrl = getHydrationRenderUrl(options?.envelope) ?? new URL(url, "http://localhost").pathname;
+	const authContext = getRouteRenderContext(resolved)?.auth ?? currentAuth();
+	const expected = withHydrationVerificationRender(() => renderResolvedForHydrationSync({
+		url: verificationUrl,
+		registry,
+		handler: resolved.handler,
+		params: resolved.params,
+		options
+	}, authContext));
+	return normalizeHydrationHtml(root.innerHTML) === normalizeHydrationHtml(expected);
+}
+//#endregion
+export { captureServerHydrationMarkup, verifyClientHydrationMarkup, verifyHydrationSyncForUrl };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@askrjs/askr",
-  "version": "0.3.1",
-  "description": "Lane-scheduled deterministic UI framework",
+  "version": "0.4.1",
+  "description": "A TypeScript UI runtime with getter-based state, fine-grained bindings, transactional commits with rollback, and one route graph for SPA, SSR, and SSG.",
   "keywords": [
     "askr",
     "framework",
@@ -128,7 +128,7 @@
     "dev": "vp dev",
     "fmt": "vp fmt .",
     "lint": "vp lint src tests test-utils benches && npm run typecheck",
-    "typecheck": "tsc --noEmit --pretty false",
+    "typecheck": "tsc --noEmit --pretty false && tsc --noEmit --pretty false -p test-utils && tsc --noEmit --pretty false -p benches && tsc --noEmit --pretty false -p tests",
     "test": "npm run test:unit && npm run test:checks && npm run test:jsdom && npm run test:browser",
     "test:browser": "vp test run -c vitest.test.browser.config.ts tests/browser",
     "test:checks": "vp test run -c vitest.test.checks.config.ts",
@@ -146,22 +146,32 @@
     "prepack": "npm run build",
     "prepublishOnly": "npm run check"
   },
-  "dependencies": {
-    "@askrjs/auth": ">=0.3.0 <0.4.0",
-    "@askrjs/schema": ">=0.3.0 <0.4.0"
-  },
   "devDependencies": {
-    "@types/node": "^26.4.1",
+    "@askrjs/auth": ">=0.4.0 <0.5.0",
+    "@askrjs/schema": ">=0.4.0 <0.5.0",
+    "@types/node": "^26.6.2",
     "@typescript/typescript6": "^6.0.2",
     "@vitest/browser-playwright": "4.1.11",
     "cross-env": "^10.1.0",
-    "jsdom": "^30.0.1",
+    "jsdom": "^30.1.1",
     "playwright": "^1.63.0",
     "publint": "^0.3.24",
     "tsd": "^0.33.0",
     "typescript": "^7.0.2",
     "vite-plus": "^0.3.1"
   },
+  "peerDependencies": {
+    "@askrjs/auth": ">=0.4.0 <0.5.0",
+    "@askrjs/schema": ">=0.4.0 <0.5.0"
+  },
+  "peerDependenciesMeta": {
+    "@askrjs/auth": {
+      "optional": true
+    },
+    "@askrjs/schema": {
+      "optional": true
+    }
+  },
   "tsd": {
     "compilerOptions": {
       "composite": false,