@barefootjs/jinja 0.31.8 → 0.31.10

package/dist/vite.js

@@ -3077,6 +3077,34 @@ var SVG_ROOT_TAGS = new Set([
   "animateTransform",
   "animateMotion"
 ]);
+var MATHML_ROOT_TAGS = new Set([
+  "math",
+  "mrow",
+  "mfrac",
+  "msup",
+  "msub",
+  "msubsup",
+  "mn",
+  "mi",
+  "mo",
+  "mtext",
+  "munder",
+  "mover",
+  "munderover",
+  "mtable",
+  "mtr",
+  "mtd",
+  "msqrt",
+  "mroot",
+  "mstyle",
+  "merror",
+  "mpadded",
+  "mphantom",
+  "menclose",
+  "semantics",
+  "annotation",
+  "annotation-xml"
+]);
 
 // ../jsx/src/ir-to-client-js/collect-elements.ts
 var EMPTY_RENDER_EXPRS = new Set(["null", "undefined", "false", "''", '""', "``"]);
@@ -3940,6 +3968,38 @@ function classify(name, origin, expr, parsed, available) {
   }
   return { kind: "derived", name, origin, expr, parsed, frees: [...frees] };
 }
+function localConstExprsByName(metadata) {
+  const out = new Map;
+  for (const c of metadata.localConstants ?? []) {
+    if (c.isModule || c.declarationKind !== "const" || c.value === undefined)
+      continue;
+    out.set(c.name, c.parsed ?? parseExpression(c.value.trim()));
+  }
+  return out;
+}
+function resolveThroughLocalConsts(parsed, localConsts) {
+  let current = parsed;
+  const maxIter = localConsts.size + 1;
+  for (let i = 0;i < maxIter; i++) {
+    const frees = freeIdentifiers(current);
+    if (frees === null)
+      break;
+    let changed = false;
+    for (const name of frees) {
+      const value = localConsts.get(name);
+      if (!value)
+        continue;
+      const inlined = inlineBinding(current, name, value);
+      if (inlined === null)
+        continue;
+      current = inlined;
+      changed = true;
+    }
+    if (!changed)
+      break;
+  }
+  return current;
+}
 function computeSsrSeedPlan(metadata) {
   const baseScope = metadata.propsParams.map((p) => p.name);
   if (metadata.propsObjectName)
@@ -3948,6 +4008,7 @@ function computeSsrSeedPlan(metadata) {
     baseScope.push(name);
   }
   const available = new Set(baseScope);
+  const localConsts = localConstExprsByName(metadata);
   const steps = [];
   for (const signal of metadata.signals) {
     if (signal.envReader) {
@@ -3959,13 +4020,13 @@ function computeSsrSeedPlan(metadata) {
       }
     }
     const expr = signal.initialValue.trim();
-    steps.push(expr === "" ? { kind: "opaque", name: signal.getter, origin: "signal" } : classify(signal.getter, "signal", expr, parseExpression(expr), available));
+    steps.push(expr === "" ? { kind: "opaque", name: signal.getter, origin: "signal" } : classify(signal.getter, "signal", expr, resolveThroughLocalConsts(parseExpression(expr), localConsts), available));
     available.add(signal.getter);
   }
   for (const memo of metadata.memos) {
     const body = extractArrowBodyExpression(memo.computation);
     const expr = body?.trim() ?? "";
-    steps.push(expr === "" ? { kind: "opaque", name: memo.name, origin: "memo" } : classify(memo.name, "memo", expr, memo.parsed ?? parseExpression(expr), available));
+    steps.push(expr === "" ? { kind: "opaque", name: memo.name, origin: "memo" } : classify(memo.name, "memo", expr, resolveThroughLocalConsts(memo.parsed ?? parseExpression(expr), localConsts), available));
     available.add(memo.name);
   }
   return { baseScope, steps };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/jinja",
-  "version": "0.31.8",
+  "version": "0.31.10",
   "description": "Jinja2 adapter for BarefootJS — compiles IR to .jinja templates and ships the Python BarefootJS rendering runtime; runs under any Python web framework (Flask, etc.)",
   "type": "module",
   "main": "./dist/index.js",
@@ -53,7 +53,7 @@
     "directory": "packages/adapter-jinja"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.31.8"
+    "@barefootjs/shared": "0.31.10"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -70,9 +70,9 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.31.8",
-    "@barefootjs/vite": "0.31.8",
-    "@barefootjs/client": "0.31.8",
+    "@barefootjs/jsx": "0.31.10",
+    "@barefootjs/vite": "0.31.10",
+    "@barefootjs/client": "0.31.10",
     "typescript": "^5.0.0",
     "vite": "^6.0.0"
   }

package/python/barefootjs/runtime.py

@@ -612,11 +612,24 @@ class BarefootJS:
         props = self._props()
         if not props:
             return ""
+        # Exclude the internal `scope_id` key from the client hydration
+        # payload: it is a server-side render detail (already carried by
+        # `_scope_id` for bf-s/bf-h/bf-m emission) with zero client runtime
+        # consumers -- the only bf-p parser
+        # (packages/client/src/runtime/hydrate.ts's parseProps -> runInit)
+        # never reads it back out. Filtered here, the single marshal
+        # boundary for bf-p, so it's excluded no matter how a `scope_id`
+        # key ends up in the props dict (found via the bf-p semantic-
+        # comparison audit against the Hono reference adapter, which never
+        # emits it).
+        client_props = {k: v for k, v in props.items() if str(k) != "scope_id"}
+        if not client_props:
+            return ""
         # The JSON must be attribute-escaped: a raw `'` inside a string value
         # (e.g. a blog paragraph) terminates the single-quoted attribute and
         # truncates the hydration payload. The browser entity-decodes the
         # attribute value, so the client's JSON.parse sees the original text.
-        j = _html_escape(self.backend.encode_json(props))
+        j = _html_escape(self.backend.encode_json(client_props))
         return f" bf-p='{j}'"
 
     # -----------------------------------------------------------------

package/src/test-render.ts

@@ -235,7 +235,7 @@ export async function renderJinjaComponent(options: RenderOptions): Promise<stri
     }
 
     // Build props dict for Python.
-    const propsPy = buildPythonProps(componentName, props, ir)
+    const { propsPy, userPropsPy } = buildPythonProps(componentName, props, ir)
 
     // Honour `__instanceId` from props for the root scope id so
     // shared-component fixtures (which pin `<ComponentName>_test`) match
@@ -262,6 +262,18 @@ bf = BarefootJS(None, {'backend': backend})
 bf._scope_id(${pyStr(rootScopeIdRaw)})
 
 props = ${propsPy}
+# Mirrors production's \`props_attr\` contract (see runtime.py's \`_props\`
+# dual-accessor and its Ruby/Perl siblings): the caller is expected to
+# seed \`_props\` before rendering the root component, so this harness
+# must call it explicitly.
+#
+# \`userPropsPy\` — NOT \`props\` above — is what \`_props\` gets: \`props\` is
+# this harness's internal vars hash (scope_id, signal/memo seed values,
+# and — when the component imports searchParams — a non-JSON-serializable
+# SearchParams reader object), none of which a real Flask route handler
+# has or passes. Production's bf-p carries none of those, only the
+# caller-facing props.
+bf._props(${userPropsPy})
 
 ${childRenderers}
 html = backend.render_named(${pyStr(toSnakeCase(componentName))}, bf, props)
@@ -480,17 +492,26 @@ function toSnakeCase(name: string): string {
 
 /**
  * Build a Python dict literal from props (+ signal / memo seeds).
+ *
+ * Returns the full internal vars-hash Python literal (`props`, what the
+ * compiled template renders against) AND `userPropsPy` — the exact raw
+ * fixture props (no defaults, no null-fill, no signal/memo seeding),
+ * mirroring production's route-handler call `bf._props(props)` verbatim.
+ * `userPropsPy` is for `bf._props(...)` (bf-p hydration payload) only —
+ * these must NOT be the same value, and `userPropsPy` must NOT be
+ * derived from `entries` or the defaulted stash: production's own bf-p
+ * carries only what the caller actually passed in, unmodified.
  */
 function buildPythonProps(
   _componentName: string,
   props: Record<string, unknown> | undefined,
   ir: ComponentIR,
-): string {
+): { propsPy: string; userPropsPy: string } {
+  // The full internal vars hash (local-template-var-name keyed, e.g.
+  // `count` for `{ n: count }`) that the compiled template renders
+  // against.
   const entries: string[] = []
 
-  const explicitScope = typeof props?.__instanceId === 'string' ? props.__instanceId : 'test'
-  entries.push(`${pyStr('scope_id')}: ${pyStr(explicitScope)}`)
-
   // Prop params with defaults (before signals, so signals can reference them).
   // Seeded through the shared `deriveStashFromDefaults` (the TS twin of the
   // production `_derive_stash_from_defaults` this harness ALSO calls at
@@ -555,23 +576,50 @@ function buildPythonProps(
     }
   }
 
+  // `bf._props(...)` payload (bf-p hydration): mirrors production's
+  // route-handler call `bf._props(props)` verbatim — the caller's raw
+  // props dict, unmodified. No default-filling, no signal/memo seeding,
+  // no rest-bag nesting: a real Flask route handler never rearranges
+  // the dict it received before handing it to `_props`. Excludes
+  // internal harness-only keys (`__instanceId` etc.), which are never a
+  // real caller-facing prop.
+  const userEntries: string[] = []
+  if (props) {
+    for (const [key, value] of Object.entries(props)) {
+      if (key.startsWith('__')) continue
+      userEntries.push(`${pyStr(key)}: ${toPyLiteral(value)}`)
+    }
+  }
+  const userPropsPy = `{${userEntries.join(', ')}}`
+
+  const explicitScope = typeof props?.__instanceId === 'string' ? props.__instanceId : 'test'
+  const fullEntries = [...entries, `${pyStr('scope_id')}: ${pyStr(explicitScope)}`]
+
   // Signal values evaluated from props (after user props).
   for (const signal of ir.metadata.signals) {
     // Env signals (#2057) are bound below via `SearchParams('')`, not from a
     // static initial value.
     if (signal.envReader) continue
+    // #2669: a self-derivation collision already got the correct RAW-prop
+    // seed above via `derivedProps` — `extractSsrDefaults` marks that with
+    // a `propName`-carrying entry (see its docstring's invariant). Skip
+    // re-seeding here or this harness's own `evaluateSignalInit` recompute
+    // clobbers the correctly-derived caller value.
+    if (rootSsrDefaults[signal.getter]?.propName !== undefined) continue
     const value = evaluateSignalInit(signal.initialValue.trim(), props)
     if (value !== null) {
-      entries.push(`${pyStr(signal.getter)}: ${toPyLiteral(value)}`)
+      fullEntries.push(`${pyStr(signal.getter)}: ${toPyLiteral(value)}`)
     }
   }
 
   // Memo values seeded from the statically-evaluated ssrDefaults, same
   // as the production plugin's before_render hook.
   for (const memo of ir.metadata.memos) {
+    // #2669: same self-derivation skip as the signal loop above.
+    if (rootSsrDefaults[memo.name]?.propName !== undefined) continue
     const entry = rootSsrDefaults[memo.name]
     const value = entry ? entry.value : 0
-    entries.push(`${pyStr(memo.name)}: ${toPyLiteral(value ?? 0)}`)
+    fullEntries.push(`${pyStr(memo.name)}: ${toPyLiteral(value ?? 0)}`)
   }
 
   // (#1922) Request-scoped `searchParams()`: bind `searchParams` to an
@@ -581,10 +629,10 @@ function buildPythonProps(
   // `.get(k)` resolves to `None` and the author's `?? default` renders. Only
   // when the component imports `searchParams`.
   if (importsSearchParams(ir.metadata)) {
-    entries.push(`${pyStr('searchParams')}: SearchParams('')`)
+    fullEntries.push(`${pyStr('searchParams')}: SearchParams('')`)
   }
 
-  return `{${entries.join(', ')}}`
+  return { propsPy: `{${fullEntries.join(', ')}}`, userPropsPy }
 }