giles
64aa417d63
All checks were successful
Build and Deploy / build-and-deploy (push) Successful in 2m6s
sx-headers attributes now use native SX dict format {:key val} instead of
JSON strings. Eliminates manual JSON string construction in both .sx files
and Python callers.
- sx.js: parse sx-headers/sx-vals as SX dict ({: prefix) with JSON fallback,
add _serializeDict for dict→attribute serialization, fix verbInfo scope in
_doFetch error handler
- html.py: serialize dict attribute values via SX serialize() not str()
- All .sx files: {:X-CSRFToken csrf} replaces (str "{\"X-CSRFToken\": ...}")
- All Python callers: {"X-CSRFToken": csrf} dict replaces f-string JSON
- Blog like: extract ~blog-like-toggle, fix POST returning wrong component,
fix emoji escapes in .sx (parser has no \U support), fix card :hx-headers
keyword mismatch, wrap sx_content in SxExpr for evaluation
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
98 lines
3.2 KiB
Python
98 lines
3.2 KiB
Python
"""
|
|
Full-page s-expression rendering.
|
|
|
|
Provides ``render_page()`` for rendering a complete HTML page from an
|
|
s-expression, bypassing Jinja entirely. Used by error handlers and
|
|
(eventually) by route handlers for fully-migrated pages.
|
|
|
|
``render_sx_response()`` is the main entry point for GET route handlers:
|
|
it calls the app's context processor, merges in route-specific kwargs,
|
|
renders the s-expression to HTML, and returns a Quart ``Response``.
|
|
|
|
Usage::
|
|
|
|
from shared.sx.page import render_page, render_sx_response
|
|
|
|
# Error pages (no context needed)
|
|
html = render_page(
|
|
'(~error-page :title "Not Found" :message "NOT FOUND" :image img :asset-url aurl)',
|
|
image="/static/errors/404.gif",
|
|
asset_url="/static",
|
|
)
|
|
|
|
# GET route handlers (auto-injects app context)
|
|
resp = await render_sx_response('(~orders-page :orders orders)', orders=orders)
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
|
|
from .jinja_bridge import sx
|
|
|
|
SEARCH_HEADERS_MOBILE = {"X-Origin": "search-mobile", "X-Search": "true"}
|
|
SEARCH_HEADERS_DESKTOP = {"X-Origin": "search-desktop", "X-Search": "true"}
|
|
|
|
|
|
def render_page(source: str, **kwargs: Any) -> str:
|
|
"""Render a full HTML page from an s-expression string.
|
|
|
|
This is a thin wrapper around ``sx()`` — it exists to make the
|
|
intent explicit in call sites (rendering a whole page, not a fragment).
|
|
"""
|
|
return sx(source, **kwargs)
|
|
|
|
|
|
async def get_template_context(**kwargs: Any) -> dict[str, Any]:
|
|
"""Gather the full template context from all registered context processors.
|
|
|
|
Returns a dict with all context variables that would normally be
|
|
available in a Jinja template, merged with any extra kwargs.
|
|
"""
|
|
import asyncio
|
|
from quart import current_app, request
|
|
|
|
ctx: dict[str, Any] = {}
|
|
|
|
# App-level context processors
|
|
for proc in current_app.template_context_processors.get(None, []):
|
|
rv = proc()
|
|
if asyncio.iscoroutine(rv):
|
|
rv = await rv
|
|
ctx.update(rv)
|
|
|
|
# Blueprint-scoped context processors
|
|
for bp_name in (request.blueprints or []):
|
|
for proc in current_app.template_context_processors.get(bp_name, []):
|
|
rv = proc()
|
|
if asyncio.iscoroutine(rv):
|
|
rv = await rv
|
|
ctx.update(rv)
|
|
|
|
# Inject Jinja globals that s-expression components need (URL helpers,
|
|
# asset_url, styles, etc.) — these aren't provided by context processors.
|
|
for key, val in current_app.jinja_env.globals.items():
|
|
if key not in ctx:
|
|
ctx[key] = val
|
|
|
|
# Expose request-scoped values that sx components need
|
|
from quart import g
|
|
if "rights" not in ctx:
|
|
ctx["rights"] = getattr(g, "rights", {})
|
|
|
|
ctx.update(kwargs)
|
|
return ctx
|
|
|
|
|
|
async def render_sx_response(source: str, **kwargs: Any) -> str:
|
|
"""Render an s-expression with the full app template context.
|
|
|
|
Calls the app's registered context processors (which provide
|
|
cart_mini, auth_menu, nav_tree, asset_url, etc.)
|
|
and merges them with the caller's kwargs before rendering.
|
|
|
|
Returns the rendered HTML string (caller wraps in Response as needed).
|
|
"""
|
|
ctx = await get_template_context(**kwargs)
|
|
return sx(source, **ctx)
|