@barefootjs/mojolicious 0.6.1 → 0.7.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,26 @@ 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()
 
   constructor(options: MojoAdapterOptions = {}) {
     super()
@@ -186,6 +234,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 +288,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 +672,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 +739,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}") %>`)
 
@@ -1307,7 +1409,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 +1919,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') {