@barefootjs/erb 0.33.4 → 0.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/erb",
-  "version": "0.33.4",
+  "version": "0.34.0",
   "description": "ERB (Embedded Ruby) adapter for BarefootJS — compiles IR to .erb templates and ships the Ruby rendering backend; runs under any Rack app (Sinatra, Rails)",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,7 +54,7 @@
     "directory": "packages/adapter-erb"
   },
   "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

@@ -18,7 +18,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 ErbEmitContext {
   /**
@@ -27,6 +27,17 @@ export interface ErbEmitContext {
    */
   readonly _searchParamsLocals: Set<string>
 
+  /**
+   * Registered lowering-plugin matchers (#2057), bound to this component's
+   * metadata at init. Read by `ErbTopLevelEmitter`'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
+   * (`convertExpressionToRuby`) 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/erb-adapter.ts

@@ -86,8 +86,6 @@ import {
   lookupStaticRecordLiteral,
   searchParamsLocalNames,
   prepareLoweringMatchers,
-  queryHrefArgs,
-  isValidHelperId,
   sortComparatorFromArrow,
   isDangerousInnerHtmlAttr,
   resolveDangerousInnerHtml,
@@ -96,6 +94,7 @@ import {
   resolveStaticLoopSource,
   derivesScopeFromSlot,
   BindingScope,
+  buildImportAliasMap,
 } from '@barefootjs/jsx'
 import { isAriaBooleanAttr, isBooleanResultExpr, isExplicitStringCall } from './boolean-result.ts'
 import type { ParsedExpr, LoweringMatcher, LoopBindingPathSegment, EscapeKind } from '@barefootjs/jsx'
@@ -259,6 +258,17 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
    * nullish-attribute omission.
    */
   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 ERB
+   * 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: ErbAdapterOptions = {}) {
     super()
@@ -288,6 +298,7 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
     this._searchParamsLocals = searchParamsLocalNames(ir.metadata)
     this._loweringMatchers = prepareLoweringMatchers(ir.metadata)
     this.localConstants = ir.metadata.localConstants ?? []
+    this.importAliases = buildImportAliasMap(ir.metadata.imports ?? [])
     this.scope = BindingScope.EMPTY
     this.errors = []
     this.childrenCaptureCounter = 0
@@ -404,7 +415,7 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
    */
   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
@@ -412,13 +423,16 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
       (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,
     }
   }
 
@@ -1323,8 +1337,12 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
   private childrenCaptureCounter = 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 ERB template naming
-    return componentName
+    return declaredName
       .replace(/([A-Z])/g, '_$1')
       .toLowerCase()
       .replace(/^_/, '')
@@ -1484,8 +1502,8 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
       {
         const m = this.parseUndefinedAlternateTernary(value.expr)
         if (m) {
-          const cond = this.convertExpressionToRuby(m.condition)
-          const val = this.convertExpressionToRuby(m.consequent)
+          const cond = this.convertExpressionToRuby('', m.testParsed)
+          const val = this.convertExpressionToRuby('', m.consequentParsed)
           return `<% if bf.truthy?(${cond}) %>${name}="<%= bf.h(${val}) %>"<% end %>`
         }
       }
@@ -1802,7 +1820,7 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
     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}` : ''
@@ -1829,6 +1847,7 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
   private get emitCtx(): ErbEmitContext {
     return {
       _searchParamsLocals: this._searchParamsLocals,
+      _loweringMatchers: this._loweringMatchers,
       resolveModuleStringConst: (name) => this.resolveModuleStringConst(name),
       resolveLiteralConst: (name) => this.resolveLiteralConst(name),
       resolveStaticRecordLiteral: (o, k) => this.resolveStaticRecordLiteral(o, k),
@@ -1885,42 +1904,16 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
       parsed = parseExpression(trimmed)
     }
 
-    // Registered call lowerings, including the built-in `queryHref` plugin,
-    // 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 `bf.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 argsRuby = queryHrefArgs(node, n => this.renderParsedExprToRuby(n))
-          return `bf.query(${argsRuby.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
-        // Ruby-callable method on their own `bf` helper object — 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.renderParsedExprToRuby(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 (`ErbTopLevelEmitter`'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',

package/src/adapter/expr/emitters.ts

@@ -46,6 +46,10 @@ import {
   identifierPath,
   matchSearchParamsMethodCall,
   sortComparatorFromArrow,
+  type LoweringEmitter,
+  type LoweringNode,
+  queryHrefArgs,
+  isValidHelperId,
 } from '@barefootjs/jsx'
 
 import type { ErbEmitContext } from '../emit-context.ts'
@@ -346,6 +350,35 @@ export class ErbTopLevelEmitter 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 `ErbAdapter.convertExpressionToRuby` 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 (e.g.
     // `props.isActive ? 'page' : undefined`) — the top-level short-circuits

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
+  // `ErbTopLevelEmitter`'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' }],
@@ -56,4 +60,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`) throws `undefined method \'length\' for nil (NoMethodError)` on real Ruby ERB — 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.',
+}