@barefootjs/mojolicious 0.6.1 → 0.8.0

package/src/adapter/mojo-adapter.ts

@@ -4,8 +4,10 @@
  * Generates Mojolicious EP template files (.html.ep) from BarefootJS IR.
  */
 
+import ts from 'typescript'
 import type {
   ComponentIR,
+  IRMetadata,
   IRNode,
   IRElement,
   IRText,
@@ -117,6 +119,32 @@ export interface MojoAdapterOptions {
   barefootJsPath?: string
 }
 
+/**
+ * Parse a const initializer's source text. Returns the unescaped string
+ * value when the whole initializer is a single string literal (or a
+ * no-substitution template literal), else `null`. Uses the TS parser so
+ * escapes/quotes resolve exactly as JS would, matching the value the Hono
+ * reference inlines at runtime.
+ */
+function parsePureStringLiteral(source: string): string | null {
+  const sf = ts.createSourceFile(
+    '__const.ts',
+    `const __x = (${source});`,
+    ts.ScriptTarget.Latest,
+    /*setParentNodes*/ false,
+  )
+  const stmt = sf.statements[0]
+  if (!stmt || !ts.isVariableStatement(stmt)) return null
+  const decl = stmt.declarationList.declarations[0]
+  let init = decl?.initializer
+  while (init && ts.isParenthesizedExpression(init)) init = init.expression
+  if (!init) return null
+  if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) {
+    return init.text
+  }
+  return null
+}
+
 export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRenderCtx> {
   name = 'mojolicious'
   extension = '.html.ep'
@@ -159,6 +187,43 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
    * true — selecting the string operator from the operand's type avoids that.
    */
   private stringValueNames: Set<string> = new Set()
+  /**
+   * Module-scope pure string-literal constants (`const X = 'literal'` at
+   * file top-level), keyed by name → resolved literal value. Populated at
+   * `generate()` entry from `ir.metadata.localConstants`. When an identifier
+   * in an expression resolves to one of these, the adapter inlines the
+   * literal instead of emitting `$X` against a stash variable that is never
+   * bound (a module const isn't a prop, signal, or local — the value would
+   * render empty). Hono inlines it for free; this restores parity. Only
+   * module-scope pure string literals qualify (see `collectModuleStringConsts`).
+   */
+  private moduleStringConsts: Map<string, string> = new Map()
+  /**
+   * Names currently bound by an enclosing loop body — the `my $<param>` and
+   * `my $<index>` bindings `renderLoop` introduces — ref-counted so nested
+   * loops compose. `resolveModuleStringConst` consults this so a loop
+   * variable whose name happens to match a module string const is NOT
+   * inlined as the const literal (mirrors the Go adapter's loop-param /
+   * loop-var shadowing guards). (#1749 review)
+   */
+  private loopBoundNames: Map<string, number> = new Map()
+  /**
+   * Prop names whose value is `undef` in the template body when the caller
+   * omits them — so a bare-reference attribute should be dropped rather
+   * than rendered as `attr=""`. The actual population criterion (see
+   * `generate()`) is: NO destructure default (`defaultValue === undefined`)
+   * AND non-rest (`!isRest`) AND non-primitive type (`type.kind !==
+   * 'primitive'`). It deliberately does NOT consult `p.optional`: the
+   * analyzer derives `optional` from the presence of a default initializer,
+   * not the `?` token, so it's not the right witness here. Excluding
+   * concrete primitives (`string`/`number`/`boolean`) mirrors the Go
+   * adapter's scope, which guards only `interface{}` (nillable) fields.
+   * Used by `elementAttrEmitter.emitExpression` to guard such an attribute
+   * with a Perl `defined $x` check (`<textarea>` omits `rows`), matching
+   * Hono's nullish-attribute omission. Concrete/defaulted props are
+   * excluded and always emit unconditionally.
+   */
+  private nullableOptionalProps: Set<string> = new Set()
 
   constructor(options: MojoAdapterOptions = {}) {
     super()
@@ -172,6 +237,31 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     this.componentName = ir.metadata.componentName
     this.propsObjectName = ir.metadata.propsObjectName ?? null
     this.propsParams = ir.metadata.propsParams.map(p => ({ name: p.name }))
+    // No-destructure-default props → `undef` when the caller omits them
+    // → guard their bare-reference attribute emission with Perl `defined`
+    // so the attribute drops instead of rendering `attr=""` (Hono-style
+    // nullish omission). A prop WITH a destructure default (`value = ''`)
+    // is never `undef` in the body and must stay unconditional, so it is
+    // excluded. This mirrors the Go adapter's nillable-field guard: there
+    // the witness is the resolved `interface{}` field type; here it is
+    // the absence of a default (the analyzer reports `rows` — a
+    // `TextareaHTMLAttributes` member destructured without a default — as
+    // no-default, `type.kind: 'unknown'`).
+    // Excludes concrete-primitive types (`string`/`number`/`boolean`)
+    // to match the Go adapter's scope, which guards only `interface{}`
+    // (nillable) fields and leaves concrete fields unconditional. So a
+    // required, no-default `string` prop still emits `attr=""` like Hono,
+    // and only nillable (`unknown`/object/array) no-default props guard.
+    this.nullableOptionalProps = new Set(
+      ir.metadata.propsParams
+        .filter(
+          p =>
+            p.defaultValue === undefined &&
+            !p.isRest &&
+            p.type?.kind !== 'primitive',
+        )
+        .map(p => p.name),
+    )
     // Record string-typed signals and props so equality comparisons against
     // them lower to `eq`/`ne` (#1672). A signal is string-typed when its
     // inferred type is `string` (the analyzer infers this from a string-literal
@@ -186,6 +276,8 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     for (const p of ir.metadata.propsParams) {
       if (isStringTypeInfo(p.type)) this.stringValueNames.add(p.name)
     }
+    this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants)
+    this.loopBoundNames.clear()
     this.errors = []
     this.childrenCaptureCounter = 0
 
@@ -238,6 +330,41 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     }
   }
 
+  /**
+   * Build the module pure-string-const map from the IR's localConstants.
+   * A const qualifies only when it is module-scope (`isModule`) and its
+   * initializer parses to a single string literal (`ts.StringLiteral` or
+   * `ts.NoSubstitutionTemplateLiteral`). Template literals with `${}`,
+   * numeric/object initializers, `Record<T,string>` maps, memos, and
+   * signals are all excluded — only a pure compile-time string can be
+   * inlined byte-for-byte.
+   */
+  private collectModuleStringConsts(constants: IRMetadata['localConstants']): Map<string, string> {
+    const map = new Map<string, string>()
+    for (const c of constants ?? []) {
+      if (!c.isModule) continue
+      if (c.value === undefined) continue
+      const literal = parsePureStringLiteral(c.value)
+      if (literal !== null) map.set(c.name, literal)
+    }
+    return map
+  }
+
+  /**
+   * Resolve an identifier to its inlined Perl single-quoted string literal
+   * when it names a module pure-string const, else `null` (the caller then
+   * falls back to its normal `$name` stash lowering). Returns the Perl
+   * literal form `'<escaped>'` ready to drop into an expression.
+   */
+  resolveModuleStringConst(name: string): string | null {
+    // A loop body introduces `my $<param>` / `my $<index>` bindings that
+    // shadow a module const of the same name — never inline inside one.
+    if (this.loopBoundNames.has(name)) return null
+    const value = this.moduleStringConsts.get(name)
+    if (value === undefined) return null
+    return `'${value.replace(/[\\']/g, m => `\\${m}`)}'`
+  }
+
   // ===========================================================================
   // Script Registration
   // ===========================================================================
@@ -587,6 +714,16 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     const indexVar = loop.iterationShape === 'keys'
       ? `$${param}`
       : loop.index ? `$${loop.index}` : '$_i'
+    // Names this loop binds in body scope. Guard module-const inlining for
+    // the whole body (children + key + filter) so a same-named loop variable
+    // isn't replaced by the const literal (#1749 review). Ref-counted for
+    // nested loops; released after the body lines are assembled below.
+    const loopBound = loop.iterationShape === 'keys'
+      ? [param]
+      : [param, loop.index ?? '_i']
+    for (const n of loopBound) {
+      this.loopBoundNames.set(n, (this.loopBoundNames.get(n) ?? 0) + 1)
+    }
     const prevInLoop = this.inLoop
     this.inLoop = true
     const renderedChildren = this.renderChildren(loop.children)
@@ -644,6 +781,13 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
       lines.push(children)
     }
 
+    // Body fully rendered — release the loop-bound names.
+    for (const n of loopBound) {
+      const c = (this.loopBoundNames.get(n) ?? 1) - 1
+      if (c <= 0) this.loopBoundNames.delete(n)
+      else this.loopBoundNames.set(n, c)
+    }
+
     lines.push(`% }`)
     lines.push(`<%== bf->comment("/loop:${loop.markerId}") %>`)
 
@@ -833,6 +977,32 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
       if (this.refuseUnsupportedAttrExpression(value.expr, name)) {
         return ''
       }
+      // Hono-style nullish-attribute omission (#textarea rows): when the
+      // attribute value is a BARE reference to an optional, no-default
+      // prop (which is `undef` when the caller omits it), guard the
+      // attribute with Perl `defined` so it DROPS rather than rendering
+      // `attr=""`. The guarded body reuses the exact normal emission, so
+      // value escaping (`<%= ... %>`) is unchanged; only the presence is
+      // conditional. The `% if`/`% end` line directives surround the
+      // attribute inline — the conformance comparator collapses the
+      // resulting whitespace, exactly like the existing boolean-attr and
+      // hydration-marker patterns. Scope is deliberately narrow (bare
+      // identifiers resolving to an optional-no-default prop) so member
+      // exprs, calls, concrete/defaulted props, and boolean attrs are
+      // unaffected and still emit unconditionally.
+      const bareId = value.expr.trim()
+      if (
+        !isBooleanAttr(name) &&
+        !value.presenceOrUndefined &&
+        this.nullableOptionalProps.has(bareId)
+      ) {
+        const perl = this.convertExpressionToPerl(value.expr)
+        const body =
+          isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name)
+            ? `${name}="<%= bf->bool_str(${perl}) %>"`
+            : `${name}="<%= ${perl} %>"`
+        return `<% if (defined ${perl}) { %>${body}<% } %>`
+      }
       if (isBooleanAttr(name) || value.presenceOrUndefined) {
         // Boolean attributes: render conditionally (present or absent).
         return `<%= ${this.convertExpressionToPerl(value.expr)} ? '${name}' : '' %>`
@@ -906,6 +1076,17 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
         )
         return `<%== bf->spread_attrs({${entries.join(', ')}}) %>`
       }
+      // Conditional inline-object spread:
+      //   `{...(COND ? { 'aria-describedby': describedBy } : {})}`
+      // Emit a Perl inline ternary of hashrefs — Perl truthiness
+      // handles the condition for free, and the falsy `{}` branch
+      // OMITS the key (`bf->spread_attrs` does NOT filter empty
+      // strings, so we cannot always-include it). Mirrors the Go
+      // adapter's IIFE-of-maps lowering (#textarea).
+      const ternaryHashref = this.conditionalSpreadToPerl(trimmed)
+      if (ternaryHashref !== null) {
+        return `<%== bf->spread_attrs(${ternaryHashref}) %>`
+      }
       const perlExpr = this.convertExpressionToPerl(value.expr)
       return `<%== bf->spread_attrs(${perlExpr}) %>`
     },
@@ -1192,6 +1373,77 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
   }
 
 
+  /**
+   * Lower a conditional inline-object spread expression
+   *   `(COND ? { 'aria-describedby': describedBy } : {})`
+   * (either branch possibly `{}`) into a Perl inline ternary of
+   * hashrefs for `bf->spread_attrs`:
+   *   `$describedBy ? { 'aria-describedby' => $describedBy } : {}`
+   *
+   * The condition is translated via `convertExpressionToPerl` (a bare
+   * prop ident becomes `$describedBy`; Perl truthiness handles the
+   * test). Object literals become Perl hashrefs with `=>`; string-
+   * literal keys are quoted, values resolve via `convertExpressionToPerl`.
+   *
+   * Returns null when the expression is NOT this shape, or when a part
+   * can't be faithfully lowered (non-static key, etc.) so the caller
+   * falls back to the standard `convertExpressionToPerl` path (which
+   * records BF101). Scoped strictly to ternary-of-object-literals so no
+   * other spread shape regresses.
+   */
+  private conditionalSpreadToPerl(expr: string): string | null {
+    const sf = ts.createSourceFile('__spread.ts', `(${expr})`, ts.ScriptTarget.Latest, true)
+    if (sf.statements.length !== 1) return null
+    const stmt = sf.statements[0]
+    if (!ts.isExpressionStatement(stmt)) return null
+    let node: ts.Expression = stmt.expression
+    while (ts.isParenthesizedExpression(node)) node = node.expression
+    if (!ts.isConditionalExpression(node)) return null
+    const unwrap = (e: ts.Expression): ts.Expression => {
+      let n = e
+      while (ts.isParenthesizedExpression(n)) n = n.expression
+      return n
+    }
+    const whenTrue = unwrap(node.whenTrue)
+    const whenFalse = unwrap(node.whenFalse)
+    if (!ts.isObjectLiteralExpression(whenTrue) || !ts.isObjectLiteralExpression(whenFalse)) {
+      return null
+    }
+    const condPerl = this.convertExpressionToPerl(node.condition.getText(sf))
+    const truePerl = this.objectLiteralToPerlHashref(whenTrue, sf)
+    const falsePerl = this.objectLiteralToPerlHashref(whenFalse, sf)
+    if (truePerl === null || falsePerl === null) return null
+    return `${condPerl} ? ${truePerl} : ${falsePerl}`
+  }
+
+  /**
+   * Convert a static object literal into a Perl hashref string for a
+   * conditional spread. Only static string/identifier keys are allowed;
+   * values resolve via `convertExpressionToPerl`. Returns null for any
+   * computed/spread/dynamic key. Empty object → `{}`.
+   */
+  private objectLiteralToPerlHashref(
+    obj: ts.ObjectLiteralExpression,
+    sf: ts.SourceFile,
+  ): string | null {
+    const entries: string[] = []
+    for (const prop of obj.properties) {
+      if (!ts.isPropertyAssignment(prop)) return null
+      let key: string
+      if (ts.isIdentifier(prop.name)) {
+        key = prop.name.text
+      } else if (ts.isStringLiteral(prop.name) || ts.isNoSubstitutionTemplateLiteral(prop.name)) {
+        key = prop.name.text
+      } else {
+        return null
+      }
+      const valPerl = this.convertExpressionToPerl(prop.initializer.getText(sf))
+      entries.push(`'${key.replace(/'/g, "\\'")}' => ${valPerl}`)
+    }
+    return entries.length === 0 ? '{}' : `{ ${entries.join(', ')} }`
+  }
+
+
   private convertExpressionToPerl(expr: string): string {
     // Parse-first lowering — parity with the Go adapter's
     // `convertExpressionToGo`. Parse the JS expression once, gate it on
@@ -1307,7 +1559,7 @@ function renderArrayMethod(
       // runtime's `bf->includes($recv, $elem)` inspects `ref($recv)`
       // and dispatches: ARRAY ref scans the list with `eq`, scalar
       // falls back to `index(..., ...) != -1`. Helper lives in
-      // packages/adapter-mojolicious/lib/BarefootJS.pm.
+      // packages/adapter-perl/lib/BarefootJS.pm.
       //
       // The `bf->` (no `$`) form matches every other helper emit —
       // in real Mojolicious `bf` is a controller helper; the
@@ -1817,6 +2069,11 @@ class MojoTopLevelEmitter implements ParsedExprEmitter {
   constructor(private readonly adapter: MojoAdapter) {}
 
   identifier(name: string): string {
+    // Module pure-string const (e.g. `const baseClasses = '...'` used in a
+    // className template literal): inline the literal value rather than emit
+    // `$baseClasses` against a stash variable that is never bound.
+    const inlined = this.adapter.resolveModuleStringConst(name)
+    if (inlined !== null) return inlined
     return `$${name}`
   }
 

package/src/test-render.ts

@@ -11,7 +11,12 @@ import { mkdir, rm } from 'node:fs/promises'
 import { resolve } from 'node:path'
 
 const RENDER_TEMP_DIR = resolve(import.meta.dir, '../.render-temp')
+// Mojo-specific lib (BarefootJS::Backend::Mojo + the plugin) lives in this
+// package; the engine-agnostic core (BarefootJS.pm) moved to @barefootjs/perl.
+// Both dirs must be on the render script's @INC so `use BarefootJS` and
+// `use BarefootJS::Backend::Mojo` resolve.
 const LIB_DIR = resolve(import.meta.dir, '../lib')
+const PERL_CORE_LIB_DIR = resolve(import.meta.dir, '../../adapter-perl/lib')
 
 export class PerlNotAvailableError extends Error {
   constructor(message: string) {
@@ -216,7 +221,7 @@ use strict;
 use warnings;
 use utf8;
 
-use lib '${LIB_DIR}';
+use lib '${LIB_DIR}', '${PERL_CORE_LIB_DIR}';
 use Mojolicious;
 use Mojo::Template;
 # Boolean values in spread bags arrive as Mojo::JSON::true /
@@ -428,6 +433,25 @@ function buildPerlProps(
     entries.push(`${param.name} => undef`)
   }
 
+  // A `{...props}` rest spread means props that aren't declared named
+  // params flow through the rest bag (`bf->spread_attrs($<restPropsName>)`),
+  // not their own top-level template var. Route them into the bag hashref so
+  // a fixture passing e.g. `placeholder` to `Input` (whose declared params
+  // are `className` / `type`) renders `placeholder="..."` via the spread
+  // rather than silently dropping it into an unused `my $placeholder`. (#1467
+  // Phase 2b — mirrors the Go harness fix in the sibling `test-render.ts`.)
+  const restPropsName = ir.metadata.restPropsName
+  const declaredParams = new Set(ir.metadata.propsParams.map(p => p.name))
+  const restBagEntries: Array<[string, unknown]> = []
+  if (restPropsName && props) {
+    for (const [key, value] of Object.entries(props)) {
+      if (key.startsWith('__')) continue
+      if (key === restPropsName || declaredParams.has(key)) continue
+      restBagEntries.push([key, value])
+    }
+  }
+  const routedKeys = new Set(restBagEntries.map(([k]) => k))
+
   // (#1407 follow-up) Default the rest-binding identifier to an
   // empty hashref so `bf->spread_attrs($extras)` in the generated
   // Mojo template doesn't trip Perl's strict-mode "Global symbol
@@ -436,13 +460,16 @@ function buildPerlProps(
   // the COMPILE path on Go, where the bag plumbing matters; the
   // runtime is a no-op when the caller leaves the bag unset, which
   // mirrors the empty-spread case on every adapter).
-  if (ir.metadata.restPropsName && !(props && ir.metadata.restPropsName in props)) {
-    entries.push(`${ir.metadata.restPropsName} => {}`)
+  // When the fixture supplied undeclared props, seed the bag with those
+  // routed entries instead of an empty hashref.
+  if (restPropsName && !(props && restPropsName in props)) {
+    entries.push(`${restPropsName} => ${toPerlLiteral(Object.fromEntries(restBagEntries))}`)
   }
 
   // Add user props
   if (props) {
     for (const [key, value] of Object.entries(props)) {
+      if (routedKeys.has(key)) continue
       if (typeof value === 'string') {
         entries.push(`${key} => '${value.replace(/'/g, "\\'")}'`)
       } else if (typeof value === 'number') {