@barefootjs/mojolicious 0.33.4 → 0.34.0

package/lib/BarefootJS/Backend/Mojo.pm

@@ -1,5 +1,5 @@
 package BarefootJS::Backend::Mojo;
-our $VERSION = "0.33.3";
+our $VERSION = "0.33.6";
 use Mojo::Base -base, -signatures;
 
 use Mojo::ByteStream qw(b);

package/lib/Mojolicious/Plugin/BarefootJS/DevReload.pm

@@ -1,5 +1,5 @@
 package Mojolicious::Plugin::BarefootJS::DevReload;
-our $VERSION = "0.33.3";
+our $VERSION = "0.33.6";
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 =head1 NAME

package/lib/Mojolicious/Plugin/BarefootJS.pm

@@ -1,5 +1,5 @@
 package Mojolicious::Plugin::BarefootJS;
-our $VERSION = "0.33.3";
+our $VERSION = "0.33.6";
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 use Mojo::File qw(path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/mojolicious",
-  "version": "0.33.4",
+  "version": "0.34.0",
   "description": "Mojolicious EP template adapter for BarefootJS - generates .html.ep files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -52,7 +52,7 @@
     "directory": "packages/adapter-mojolicious"
   },
   "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",
     "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 MojoEmitContext {
   /**
@@ -27,6 +27,17 @@ export interface MojoEmitContext {
    */
   readonly _searchParamsLocals: Set<string>
 
+  /**
+   * Registered lowering-plugin matchers (#2057), bound to this component's
+   * metadata at init. Read by `MojoTopLevelEmitter`'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
+   * (`convertExpressionToPerl`) 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

@@ -27,6 +27,10 @@ import { groupBinaryOperand,
   matchSearchParamsMethodCall,
   sortComparatorFromArrow,
   asCallbackMethodCall,
+  type LoweringEmitter,
+  type LoweringNode,
+  queryHrefArgs,
+  isValidHelperId,
 } from '@barefootjs/jsx'
 
 import type { MojoEmitContext } from '../emit-context.ts'
@@ -323,6 +327,35 @@ export class MojoTopLevelEmitter 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 `MojoAdapter.convertExpressionToPerl` 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
     // (#1897, pagination's `props.isActive ? 'page' : undefined`) — the

package/src/adapter/mojo-adapter.ts

@@ -56,8 +56,6 @@ import {
   lookupStaticRecordLiteral,
   searchParamsLocalNames,
   prepareLoweringMatchers,
-  queryHrefArgs,
-  isValidHelperId,
   sortComparatorFromArrow,
   isLowerableLoopDestructure,
   isDangerousInnerHtmlAttr,
@@ -67,6 +65,7 @@ import {
   resolveStaticLoopSource,
   derivesScopeFromSlot,
   BindingScope,
+  buildImportAliasMap,
 } from '@barefootjs/jsx'
 import { isAriaBooleanAttr, isBooleanResultExpr } from './boolean-result.ts'
 import type { ParsedExpr, LoweringMatcher } from '@barefootjs/jsx'
@@ -256,6 +255,18 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
    */
   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 Mojo 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: MojoAdapterOptions = {}) {
     super()
     this.options = {
@@ -285,6 +296,7 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     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
@@ -390,7 +402,7 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
    */
   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
@@ -398,13 +410,16 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
       (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,
     }
   }
 
@@ -1257,8 +1272,12 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
   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 Mojo template naming
-    return componentName
+    return declaredName
       .replace(/([A-Z])/g, '_$1')
       .toLowerCase()
       .replace(/^_/, '')
@@ -1441,8 +1460,8 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
       {
         const m = this.parseUndefinedAlternateTernary(value.expr)
         if (m) {
-          const cond = this.convertExpressionToPerl(m.condition)
-          const val = this.convertExpressionToPerl(m.consequent)
+          const cond = this.convertExpressionToPerl('', m.testParsed)
+          const val = this.convertExpressionToPerl('', m.consequentParsed)
           return `<% if (${cond}) { %>${name}="<%= ${val} %>"<% } %>`
         }
       }
@@ -1764,7 +1783,7 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     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
     // Surface the `isSupported` reason so the diagnostic is as
     // actionable as the Go adapter's BF101 — keeps cross-adapter
@@ -1794,6 +1813,7 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
   private get emitCtx(): MojoEmitContext {
     return {
       _searchParamsLocals: this._searchParamsLocals,
+      _loweringMatchers: this._loweringMatchers,
       resolveModuleStringConst: (name) => this.resolveModuleStringConst(name),
       resolveLiteralConst: (name) => this.resolveLiteralConst(name),
       resolveStaticRecordLiteral: (o, k) => this.resolveStaticRecordLiteral(o, k),
@@ -1850,42 +1870,16 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
       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 `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 `1`, 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 argsGo = queryHrefArgs(node, n => this.renderParsedExprToPerl(n))
-          return `bf->query(${argsGo.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
-        // method on their own Mojolicious `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.renderParsedExprToPerl(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 (`MojoTopLevelEmitter`'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/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
+  // `MojoTopLevelEmitter`'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

@@ -28,4 +28,6 @@ import type { RenderDivergences } from '@barefootjs/jsx'
 export const renderDivergences: RenderDivergences = {
   'children-passthrough-renamed':
     'A renamed `children` destructure emits the local alias as a template variable; the stash defines only `children`, so the Perl render dies (#2788).',
+  'aliased-loop-source':
+    'A `.map()` loop whose source is a local const alias of a signal getter (`const items__alias = items`) dies inside `Mojo::Template::process` on real Mojolicious — 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.',
 }