@barefootjs/rust 0.33.4 → 0.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/rust",
-  "version": "0.33.4",
+  "version": "0.34.0",
   "description": "minijinja (Rust) adapter for BarefootJS — compiles IR to .j2 templates and ships a Rust rendering runtime (packages/adapter-rust/runtime/); runs under any Rust web framework (axum, etc.)",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,7 +54,7 @@
     "directory": "packages/adapter-rust"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.33.4"
+    "@barefootjs/shared": "0.34.0"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -71,9 +71,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

@@ -20,7 +20,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 {
   /**
@@ -29,6 +29,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

@@ -60,6 +60,10 @@ import { groupBinaryOperand,
   identifierPath,
   matchSearchParamsMethodCall,
   sortComparatorFromArrow,
+  type LoweringEmitter,
+  type LoweringNode,
+  queryHrefArgs,
+  isValidHelperId,
 } from '@barefootjs/jsx'
 
 import type { JinjaEmitContext } from '../emit-context.ts'
@@ -314,6 +318,35 @@ 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 `MinijinjaAdapter.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.
+        if (node.kind === 'guard-list' && node.helper === 'query') {
+          const qArgs = queryHrefArgs(node, emit)
+          return `bf.query(${qArgs.join(', ')})`
+        }
+        // Generic `helper-call` (#2069) — a userland `LoweringPlugin`'s
+        // single runtime-helper invocation; `bf.<helper>(args…)` mirrors
+        // the `query` helper's own naming convention.
+        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/minijinja-adapter.ts

@@ -163,8 +163,6 @@ import {
   lookupStaticRecordLiteral,
   searchParamsLocalNames,
   prepareLoweringMatchers,
-  queryHrefArgs,
-  isValidHelperId,
   sortComparatorFromArrow,
   isDangerousInnerHtmlAttr,
   resolveDangerousInnerHtml,
@@ -173,6 +171,7 @@ import {
   resolveStaticLoopSource,
   derivesScopeFromSlot,
   BindingScope,
+  buildImportAliasMap,
 } from '@barefootjs/jsx'
 import { isAriaBooleanAttr, isBooleanResultExpr, isExplicitStringCall } from './boolean-result.ts'
 import type { ParsedExpr, LoweringMatcher, LoopBindingPathSegment } from '@barefootjs/jsx'
@@ -333,6 +332,18 @@ export class MinijinjaAdapter extends BaseAdapter implements IRNodeEmitter<Jinja
    */
   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 call against the child's own
+   * declared name (`Foo`, what `foo.tsx` registers its minijinja 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: MinijinjaAdapterOptions = {}) {
     super()
     this.options = {
@@ -361,6 +372,7 @@ export class MinijinjaAdapter extends BaseAdapter implements IRNodeEmitter<Jinja
     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
 
@@ -1308,8 +1320,12 @@ export class MinijinjaAdapter extends BaseAdapter implements IRNodeEmitter<Jinja
   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(/^_/, '')
@@ -1464,8 +1480,8 @@ export class MinijinjaAdapter extends BaseAdapter implements IRNodeEmitter<Jinja
       {
         const m = this.parseUndefinedAlternateTernary(value.expr)
         if (m) {
-          const cond = this.convertConditionToJinja(m.condition)
-          const val = this.convertExpressionToJinja(m.consequent)
+          const cond = this.convertConditionToJinja('', m.testParsed)
+          const val = this.convertExpressionToJinja('', m.consequentParsed)
           return `\n{% if ${cond} %}\n${name}="{{ bf.string(${val}) }}"\n{% endif %}\n`
         }
       }
@@ -1733,7 +1749,7 @@ export class MinijinjaAdapter extends BaseAdapter implements IRNodeEmitter<Jinja
     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}` : ''
@@ -1760,6 +1776,7 @@ export class MinijinjaAdapter extends BaseAdapter implements IRNodeEmitter<Jinja
   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),
@@ -1814,42 +1831,16 @@ export class MinijinjaAdapter extends BaseAdapter implements IRNodeEmitter<Jinja
       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
-        // MiniJinja-callable function 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(', ')})`
-        }
-      }
-    }
-
     // `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)
+    // Registered call lowerings (#2057) — including the built-in `queryHref`
+    // plugin — are consulted by this gate no matter where the call sits in
+    // the tree (`JinjaTopLevelEmitter`'s `lowering` seam does the actual
+    // rendering below, via `emitParsedExpr`'s shared `call` case).
+    const supportOpts = { loweringMatchers: this._loweringMatchers }
+    const support = pos === 'value' ? isSupportedValue(parsed, supportOpts) : isSupported(parsed, supportOpts)
     if (!support.supported) {
       this.errors.push({
         code: 'BF101',
@@ -1918,7 +1909,7 @@ export class MinijinjaAdapter extends BaseAdapter implements IRNodeEmitter<Jinja
    */
   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
@@ -1926,13 +1917,16 @@ export class MinijinjaAdapter extends BaseAdapter implements IRNodeEmitter<Jinja
       (alt.kind === 'identifier' && (alt.name === 'undefined' || alt.name === 'null')) ||
       (alt.kind === 'literal' && (alt.value === null || alt.value === undefined))
     if (!isUndef) return null
-    // Serialise the parsed sub-expressions back to JS source rather than
-    // slicing `expr` text — `indexOf('?')` / `lastIndexOf(':')` would
-    // mis-split when the consequent itself contains `?` / `:` inside a
-    // string or nested ternary (`cond ? 'a:b' : undefined`).
+    // `condition`/`consequent` are DEBUG text only (`exprToString` renders an
+    // unsupported nested shape like an object literal as non-reparseable
+    // `[UNSUPPORTED: …]` text) — callers that need to re-lower the
+    // sub-expression must use `testParsed`/`consequentParsed` (the actual
+    // parsed trees) as `preParsed`, not re-parse these strings.
     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' }],
@@ -64,4 +68,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

@@ -17,4 +17,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>` through real minijinja — 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.',
+}