@barefootjs/jinja 0.33.4 → 0.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/jinja",
-  "version": "0.33.4",
+  "version": "0.34.0",
   "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.33.4"
+    "@barefootjs/shared": "0.34.0"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -70,9 +70,9 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.33.4",
-    "@barefootjs/vite": "0.33.4",
-    "@barefootjs/client": "0.33.4",
+    "@barefootjs/jsx": "0.34.0",
+    "@barefootjs/vite": "0.34.0",
+    "@barefootjs/client": "0.34.0",
     "typescript": "^5.0.0",
     "vite": "^6.0.0"
   }

package/src/adapter/emit-context.ts

@@ -19,7 +19,7 @@
  * rather than re-exposing the whole adapter.
  */
 
-import type { ParsedExpr, CompilerError, IRMetadata } from '@barefootjs/jsx'
+import type { ParsedExpr, CompilerError, IRMetadata, LoweringMatcher } from '@barefootjs/jsx'
 
 export interface JinjaEmitContext {
   /**
@@ -28,6 +28,17 @@ export interface JinjaEmitContext {
    */
   readonly _searchParamsLocals: Set<string>
 
+  /**
+   * Registered lowering-plugin matchers (#2057), bound to this component's
+   * metadata at init. Read by `JinjaTopLevelEmitter`'s `lowering` seam
+   * (#2843) so a registered call — the built-in `queryHref`, or any
+   * userland plugin — is recognised no matter where it sits in an
+   * expression tree (a ternary branch, a template-literal interpolation, …),
+   * not only when it's the call the adapter's own top-level conversion
+   * entry point (`convertExpressionToJinja`) is asked to lower directly.
+   */
+  readonly _loweringMatchers: readonly LoweringMatcher[]
+
   /**
    * Inline a module-scope pure string-literal const by name as the resolved
    * literal value, or null when the name is not such a const.

package/src/adapter/expr/emitters.ts

@@ -51,6 +51,8 @@
 import { groupBinaryOperand,
   groupObjectLiteralSegments,
   type ParsedExprEmitter,
+  type LoweringEmitter,
+  type LoweringNode,
   type HigherOrderMethod,
   type ArrayMethod,
   type LiteralType,
@@ -61,6 +63,8 @@ import { groupBinaryOperand,
   identifierPath,
   matchSearchParamsMethodCall,
   sortComparatorFromArrow,
+  queryHrefArgs,
+  isValidHelperId,
 } from '@barefootjs/jsx'
 
 import type { JinjaEmitContext } from '../emit-context.ts'
@@ -323,6 +327,45 @@ export class JinjaTopLevelEmitter implements ParsedExprEmitter {
     this.ctx = ctx
   }
 
+  /**
+   * Registered-lowering seam (#2843): `emitParsedExpr`'s shared `call` case
+   * tries every matcher here BEFORE `call()` itself, so a registered call
+   * (the built-in `queryHref`, or any userland plugin) is recognised no
+   * matter where it sits in the tree. `render` is what used to live inline
+   * in `JinjaAdapter.convertExpressionToJinja` before the object-literal
+   * support-gate refusal (`checkSupport`'s `call` arm, now itself
+   * registry-aware) made the pre-gate special case unnecessary.
+   */
+  get lowering(): LoweringEmitter {
+    return {
+      matchers: this.ctx._loweringMatchers,
+      render: (node: LoweringNode, emit: (e: ParsedExpr) => string): string | null => {
+        // `query` guard-list — `queryHref`-shaped. The helper includes a
+        // pair iff its guard is truthy AND its value is a non-empty string
+        // (the client's `if (value)`): a plain `key: v` passes guard
+        // `true`, a conditional `key: cond ? v : undefined` passes the
+        // lowered cond. Only the `query` helper renders to `bf.query`;
+        // another guard-list helper must not be silently mis-rendered as
+        // a query.
+        if (node.kind === 'guard-list' && node.helper === 'query') {
+          const qArgs = queryHrefArgs(node, emit)
+          return `bf.query(${qArgs.join(', ')})`
+        }
+        // Generic `helper-call` (#2069) — the neutral vocabulary's escape
+        // hatch for a userland `LoweringPlugin` that lowers to a single
+        // runtime-helper invocation. `bf.<helper>(args…)` mirrors the
+        // `query` helper's own naming convention exactly: the framework
+        // renders the call, the plugin author registers `<helper>` as a
+        // Jinja-callable function/filter in their own runtime — same
+        // contract as `bf.query` itself, just not built in.
+        if (node.kind === 'helper-call' && isValidHelperId(node.helper)) {
+          return `bf.${node.helper}(${node.args.map(emit).join(', ')})`
+        }
+        return null
+      },
+    }
+  }
+
   identifier(name: string): string {
     // `undefined` / `null` nested inside a larger expression tree — Jinja
     // `none` (#1897).

package/src/adapter/jinja-adapter.ts

@@ -138,8 +138,6 @@ import {
   lookupStaticRecordLiteral,
   searchParamsLocalNames,
   prepareLoweringMatchers,
-  queryHrefArgs,
-  isValidHelperId,
   sortComparatorFromArrow,
   isDangerousInnerHtmlAttr,
   resolveDangerousInnerHtml,
@@ -148,6 +146,7 @@ import {
   resolveStaticLoopSource,
   derivesScopeFromSlot,
   BindingScope,
+  buildImportAliasMap,
 } from '@barefootjs/jsx'
 import { isAriaBooleanAttr, isBooleanResultExpr, isExplicitStringCall } from './boolean-result.ts'
 import type { ParsedExpr, LoweringMatcher } from '@barefootjs/jsx'
@@ -285,6 +284,18 @@ export class JinjaAdapter extends BaseAdapter implements IRNodeEmitter<JinjaRend
    */
   private nullableOptionalProps: Set<string> = new Set()
 
+  /**
+   * Local alias -> declared/exported name for imported components (#2822,
+   * the SSR-side counterpart of #2777's client-JS registry-key fix). A
+   * child referenced under an import alias (`import { Foo as Bar }`,
+   * `<Bar/>`) must build its cross-template `render_child` call against
+   * the child's own declared name (`Foo`, what `foo.tsx` registers its
+   * Jinja partial as) — never the caller-local binding. Built once per
+   * compile from `ir.metadata.imports` via the shared `buildImportAliasMap`
+   * (`@barefootjs/jsx`) and read by `toTemplateName`.
+   */
+  private importAliases: Map<string, string> = new Map()
+
   constructor(options: JinjaAdapterOptions = {}) {
     super()
     this.options = {
@@ -313,6 +324,7 @@ export class JinjaAdapter extends BaseAdapter implements IRNodeEmitter<JinjaRend
     this.moduleStringConsts = collectModuleStringConsts(ir.metadata.localConstants)
     this._searchParamsLocals = searchParamsLocalNames(ir.metadata)
     this._loweringMatchers = prepareLoweringMatchers(ir.metadata)
+    this.importAliases = buildImportAliasMap(ir.metadata.imports ?? [])
     this.errors = []
     this.childrenCaptureCounter = 0
 
@@ -1256,8 +1268,12 @@ export class JinjaAdapter extends BaseAdapter implements IRNodeEmitter<JinjaRend
   private presenceVarCounter = 0
 
   private toTemplateName(componentName: string): string {
+    // Resolve an import alias (`import { Foo as Bar }`, `<Bar/>`) back to
+    // the child's own declared name BEFORE snake-casing (#2822) — `Bar`
+    // has no `foo.tsx`-registered partial; only `Foo` does.
+    const declaredName = this.importAliases.get(componentName) ?? componentName
     // Convert PascalCase to snake_case for template naming.
-    return componentName
+    return declaredName
       .replace(/([A-Z])/g, '_$1')
       .toLowerCase()
       .replace(/^_/, '')
@@ -1412,8 +1428,13 @@ export class JinjaAdapter extends BaseAdapter implements IRNodeEmitter<JinjaRend
       {
         const m = this.parseUndefinedAlternateTernary(value.expr)
         if (m) {
-          const cond = this.convertConditionToJinja(m.condition)
-          const val = this.convertExpressionToJinja(m.consequent)
+          // Pass the PARSED sub-trees through as `preParsed` (#2843 review)
+          // rather than re-parsing `m.condition`/`m.consequent` — those are
+          // `exprToString` debug text, which renders any nested
+          // `object-literal` (e.g. a registered call's params, `queryHref`'s
+          // `{ tag }`) as a non-reparseable `[UNSUPPORTED: …]` placeholder.
+          const cond = this.convertConditionToJinja(m.condition, m.testParsed)
+          const val = this.convertExpressionToJinja(m.consequent, m.consequentParsed)
           return `\n{% if ${cond} %}\n${name}="{{ bf.string(${val}) }}"\n{% endif %}\n`
         }
       }
@@ -1675,7 +1696,7 @@ export class JinjaAdapter extends BaseAdapter implements IRNodeEmitter<JinjaRend
     const hasTaggedTemplate = /[A-Za-z_$][\w$]*\s*`/.test(probe)
     if (!startsAsObjectLiteral && !hasTaggedTemplate) return false
     const parsed = parseExpression(expr.trim())
-    const support = isSupported(parsed)
+    const support = isSupported(parsed, { loweringMatchers: this._loweringMatchers })
     if (parsed.kind !== 'unsupported' && support.supported) return false
     const reason = support.reason ?? (parsed.kind === 'unsupported' ? parsed.reason : undefined)
     const reasonLine = reason ? `\n${reason}` : ''
@@ -1702,6 +1723,7 @@ export class JinjaAdapter extends BaseAdapter implements IRNodeEmitter<JinjaRend
   private get emitCtx(): JinjaEmitContext {
     return {
       _searchParamsLocals: this._searchParamsLocals,
+      _loweringMatchers: this._loweringMatchers,
       _resolveModuleStringConst: (name) => this._resolveModuleStringConst(name),
       _resolveLiteralConst: (name) => this._resolveLiteralConst(name),
       _resolveStaticRecordLiteral: (o, k) => this._resolveStaticRecordLiteral(o, k),
@@ -1756,42 +1778,22 @@ export class JinjaAdapter extends BaseAdapter implements IRNodeEmitter<JinjaRend
       parsed = parseExpression(trimmed)
     }
 
-    // Registered call lowerings (#2057) — including the built-in `queryHref`
-    // plugin (#2042), which lowers `queryHref(base, { … })` to a neutral
-    // `guard-list` on the `query` helper → `bf.query(base, <triples>)`.
-    // Recognised before the support gate because the object-literal arg is
-    // otherwise `unsupported` (BF101). The `query` helper includes a pair iff its
-    // guard is truthy AND its value is a non-empty string (the client's
-    // `if (value)`): a plain `key: v` passes guard `true`, a conditional
-    // `key: cond ? v : undefined` passes the lowered cond. Only the `query`
-    // helper renders to `bf.query`; another guard-list helper must not be
-    // silently mis-rendered as a query.
-    if (parsed.kind === 'call') {
-      for (const matcher of this._loweringMatchers) {
-        const node = matcher(parsed.callee, parsed.args)
-        if (node?.kind === 'guard-list' && node.helper === 'query') {
-          const qArgs = queryHrefArgs(node, n => this.renderParsedExprToJinja(n))
-          return `bf.query(${qArgs.join(', ')})`
-        }
-        // Generic `helper-call` (#2069) — the neutral vocabulary's escape
-        // hatch for a userland `LoweringPlugin` that lowers to a single
-        // runtime-helper invocation. `bf.<helper>(args…)` mirrors the
-        // `query` helper's own naming convention exactly: the framework
-        // renders the call, the plugin author registers `<helper>` as a
-        // Jinja-callable function/filter in their own runtime — same
-        // contract as `bf.query` itself, just not built in.
-        if (node?.kind === 'helper-call' && isValidHelperId(node.helper)) {
-          const argsX = node.args.map(a => this.renderParsedExprToJinja(a))
-          return `bf.${node.helper}(${argsX.join(', ')})`
-        }
-      }
-    }
-
+    // #2843: a registered lowering plugin's call (the built-in `queryHref`,
+    // or any userland plugin) is recognised no matter where it sits in the
+    // tree — a ternary branch, a template-literal interpolation, … — not
+    // only when `parsed.kind === 'call'` directly. That recognition now
+    // lives in `JinjaTopLevelEmitter`'s `lowering` seam, consulted by
+    // `emitParsedExpr`'s shared `call` dispatch; the support gate below is
+    // passed `this._loweringMatchers` so a matched call's params (e.g.
+    // `queryHref`'s object literal, otherwise `unsupported` at `rendered`
+    // position) are admitted wherever the call is nested.
+    //
     // `pos` distinguishes a derived-seed RHS (an assignment, checked via
     // `isSupportedValue`) from every other, genuinely rendered call site —
     // the rendered gate would otherwise re-refuse a tree the seed plan
     // already classified `derived` at value position (#2696 review).
-    const support = pos === 'value' ? isSupportedValue(parsed) : isSupported(parsed)
+    const supportOpts = { loweringMatchers: this._loweringMatchers }
+    const support = pos === 'value' ? isSupportedValue(parsed, supportOpts) : isSupported(parsed, supportOpts)
     if (!support.supported) {
       this.errors.push({
         code: 'BF101',
@@ -1857,10 +1859,21 @@ export class JinjaAdapter extends BaseAdapter implements IRNodeEmitter<JinjaRend
    * Parse `cond ? value : undefined` (or `: null`), returning the
    * condition/consequent source spans, else `null`. Used for the
    * attribute-omission rule (#1897).
+   *
+   * `testParsed`/`consequentParsed` (#2843 review) are the ACTUAL parsed
+   * sub-trees, for the caller to pass through as `preParsed` — `condition`/
+   * `consequent` are `exprToString` output, a DEBUG formatter that renders
+   * any nested `object-literal` as the non-reparseable `[UNSUPPORTED: …]`
+   * placeholder (unlike `stringifyParsedExpr`, meant for round-tripping).
+   * Re-parsing THAT string for a consequent like `queryHref(base, { tag })`
+   * would corrupt the call's args before the lowering registry — now
+   * consulted at any nesting depth (#2843) — ever sees them. Kept for any
+   * caller that only needs the string form; the parsed trees are the
+   * correct input wherever the caller can accept `preParsed`.
    */
   parseUndefinedAlternateTernary(
     expr: string,
-  ): { condition: string; consequent: string } | null {
+  ): { condition: string; consequent: string; testParsed: ParsedExpr; consequentParsed: ParsedExpr } | null {
     const parsed = parseExpression(expr.trim())
     if (parsed?.kind !== 'conditional') return null
     const alt = parsed.alternate
@@ -1875,6 +1888,8 @@ export class JinjaAdapter extends BaseAdapter implements IRNodeEmitter<JinjaRend
     return {
       condition: exprToString(parsed.test),
       consequent: exprToString(parsed.consequent),
+      testParsed: parsed.test,
+      consequentParsed: parsed.consequent,
     }
   }
 

package/src/conformance-pins.ts

@@ -10,6 +10,10 @@
 import type { ConformancePins } from '@barefootjs/jsx'
 
 export const conformancePins: ConformancePins = {
+  // #2843: graduated — a registered lowering call inside a ternary
+  // attribute branch (or any nested value position) is now recognised via
+  // `JinjaTopLevelEmitter`'s `lowering` seam + the registry-aware support
+  // gate, matching the direct-call attribute path exactly.
   'filter-typeof-predicate': [{ code: 'BF021', severity: 'error' }],
   'map-array-builder-body': [{ code: 'BF021', severity: 'error' }],
   'map-array-builder-escaping': [{ code: 'BF021', severity: 'error' }],
@@ -63,4 +67,11 @@ export const conformancePins: ConformancePins = {
   // `rich-prop-client-read` above.
   'jsx-element-prop-ternary': [{ code: 'BF021', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2667' }],
   'jsx-element-prop-array': [{ code: 'BF021', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2667' }],
+  // #2771: a reactive primitive invoked through a namespace import
+  // (`import * as bf from '@barefootjs/client'`, `bf.createSignal(...)`)
+  // that the analyzer's checker-less fast path cannot recognize refuses
+  // loudly (BF013) instead of silently dropping the declaration — fired
+  // in the shared analyzer pass ahead of any adapter's `adapter.generate()`,
+  // so all nine adapters (including Hono) pin this identically.
+  'namespace-import-primitive': [{ code: 'BF013', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2771' }],
 }

package/src/render-divergences.ts

@@ -15,4 +15,7 @@ import type { RenderDivergences } from '@barefootjs/jsx'
 // at value position and the runtime evaluator's `object-literal` case
 // now merges it, so the seed classifies `derived` and SSRs identically
 // to Hono.
-export const renderDivergences: RenderDivergences = {}
+export const renderDivergences: RenderDivergences = {
+  'aliased-loop-source':
+    'A `.map()` loop whose source is a local const alias of a signal getter (`const items__alias = items`) SSRs an empty `<ul>` on real Jinja2 — the seeded loop data is keyed by the signal\'s real name (`items`), and the alias hop is never resolved when deciding what to seed under `items__alias`. This is the SSR-side twin of #2778 (fixed for the CSR client-JS template in the same PR that added this fixture) — that fix only touches client-JS emission, not SSR data-seeding. Tracked at https://github.com/piconic-ai/barefootjs/issues/2813; graduate by resolving the alias hop at SSR-seeding time using the same `resolveAliasOrigin`/`resolveGetterAliases` mechanism #2778 introduced, rather than a third alias-hop walker.',
+}