@barefootjs/mojolicious 0.6.1 → 0.8.0

package/dist/index.js

@@ -1,4 +1,5 @@
 // src/adapter/mojo-adapter.ts
+import ts from "typescript";
 import {
   BaseAdapter,
   isBooleanAttr,
@@ -80,6 +81,22 @@ function resolveJsxChildrenProp(props) {
     return [];
   return prop.value.children;
 }
+function parsePureStringLiteral(source) {
+  const sf = ts.createSourceFile("__const.ts", `const __x = (${source});`, ts.ScriptTarget.Latest, 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;
+}
 
 class MojoAdapter extends BaseAdapter {
   name = "mojolicious";
@@ -94,6 +111,9 @@ class MojoAdapter extends BaseAdapter {
   propsObjectName = null;
   propsParams = [];
   stringValueNames = new Set;
+  moduleStringConsts = new Map;
+  loopBoundNames = new Map;
+  nullableOptionalProps = new Set;
   constructor(options = {}) {
     super();
     this.options = {
@@ -105,6 +125,7 @@ class MojoAdapter extends BaseAdapter {
     this.componentName = ir.metadata.componentName;
     this.propsObjectName = ir.metadata.propsObjectName ?? null;
     this.propsParams = ir.metadata.propsParams.map((p) => ({ name: p.name }));
+    this.nullableOptionalProps = new Set(ir.metadata.propsParams.filter((p) => p.defaultValue === undefined && !p.isRest && p.type?.kind !== "primitive").map((p) => p.name));
     this.stringValueNames = new Set;
     for (const s of ir.metadata.signals) {
       if (isStringTypeInfo(s.type) || isBareStringLiteral(s.initialValue)) {
@@ -115,6 +136,8 @@ class MojoAdapter extends BaseAdapter {
       if (isStringTypeInfo(p.type))
         this.stringValueNames.add(p.name);
     }
+    this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants);
+    this.loopBoundNames.clear();
     this.errors = [];
     this.childrenCaptureCounter = 0;
     if (!options?.siblingTemplatesRegistered) {
@@ -139,6 +162,27 @@ class MojoAdapter extends BaseAdapter {
       extension: this.extension
     };
   }
+  collectModuleStringConsts(constants) {
+    const map = new Map;
+    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;
+  }
+  resolveModuleStringConst(name) {
+    if (this.loopBoundNames.has(name))
+      return null;
+    const value = this.moduleStringConsts.get(name);
+    if (value === undefined)
+      return null;
+    return `'${value.replace(/[\\']/g, (m) => `\\${m}`)}'`;
+  }
   generateScriptRegistrations(ir, scriptBaseName) {
     const hasInteractivity = this.hasClientInteractivity(ir);
     if (!hasInteractivity)
@@ -405,6 +449,10 @@ ${whenTrue}
     }
     const param = loop.param;
     const indexVar = loop.iterationShape === "keys" ? `$${param}` : loop.index ? `$${loop.index}` : "$_i";
+    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);
@@ -438,6 +486,13 @@ ${renderedChildren}` : renderedChildren;
     } else {
       lines.push(children);
     }
+    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}") %>`);
     return lines.join(`
@@ -529,6 +584,12 @@ ${children}`;
       if (this.refuseUnsupportedAttrExpression(value.expr, name)) {
         return "";
       }
+      const bareId = value.expr.trim();
+      if (!isBooleanAttr(name) && !value.presenceOrUndefined && this.nullableOptionalProps.has(bareId)) {
+        const perl2 = this.convertExpressionToPerl(value.expr);
+        const body = isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) ? `${name}="<%= bf->bool_str(${perl2}) %>"` : `${name}="<%= ${perl2} %>"`;
+        return `<% if (defined ${perl2}) { %>${body}<% } %>`;
+      }
       if (isBooleanAttr(name) || value.presenceOrUndefined) {
         return `<%= ${this.convertExpressionToPerl(value.expr)} ? '${name}' : '' %>`;
       }
@@ -549,6 +610,10 @@ ${children}`;
         const entries = this.propsParams.map((p) => `${JSON.stringify(p.name)} => $${p.name}`);
         return `<%== bf->spread_attrs({${entries.join(", ")}}) %>`;
       }
+      const ternaryHashref = this.conditionalSpreadToPerl(trimmed);
+      if (ternaryHashref !== null) {
+        return `<%== bf->spread_attrs(${ternaryHashref}) %>`;
+      }
       const perlExpr = this.convertExpressionToPerl(value.expr);
       return `<%== bf->spread_attrs(${perlExpr}) %>`;
     },
@@ -713,6 +778,54 @@ ${reason}` : "";
     });
     return true;
   }
+  conditionalSpreadToPerl(expr) {
+    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 = stmt.expression;
+    while (ts.isParenthesizedExpression(node))
+      node = node.expression;
+    if (!ts.isConditionalExpression(node))
+      return null;
+    const unwrap = (e) => {
+      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}`;
+  }
+  objectLiteralToPerlHashref(obj, sf) {
+    const entries = [];
+    for (const prop of obj.properties) {
+      if (!ts.isPropertyAssignment(prop))
+        return null;
+      let key;
+      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(", ")} }`;
+  }
   convertExpressionToPerl(expr) {
     const trimmed = expr.trim();
     if (trimmed === "")
@@ -1056,6 +1169,9 @@ class MojoTopLevelEmitter {
     this.adapter = adapter;
   }
   identifier(name) {
+    const inlined = this.adapter.resolveModuleStringConst(name);
+    if (inlined !== null)
+      return inlined;
     return `$${name}`;
   }
   literal(value, literalType) {

package/dist/test-render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-render.d.ts","sourceRoot":"","sources":["../src/test-render.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKxE;AAkCD,MAAM,WAAW,aAAa;IAC5B,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,8BAA8B;IAC9B,OAAO,EAAE,OAAO,iBAAiB,EAAE,eAAe,CAAA;IAClD,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CA2MjF;AAgND;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAuBT"}
+{"version":3,"file":"test-render.d.ts","sourceRoot":"","sources":["../src/test-render.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAeH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKxE;AAkCD,MAAM,WAAW,aAAa;IAC5B,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,8BAA8B;IAC9B,OAAO,EAAE,OAAO,iBAAiB,EAAE,eAAe,CAAA;IAClD,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CA2MjF;AAsOD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAuBT"}

package/lib/BarefootJS/Backend/Mojo.pm

@@ -0,0 +1,91 @@
+package BarefootJS::Backend::Mojo;
+our $VERSION = "0.01";
+use Mojo::Base -base, -signatures;
+
+use Mojo::ByteStream qw(b);
+use Mojo::JSON qw(to_json);
+use Scalar::Util qw(weaken);
+
+# ---------------------------------------------------------------------------
+# Reference rendering backend (Mojolicious / Mojo::Template).
+# ---------------------------------------------------------------------------
+#
+# BarefootJS.pm holds all the template-engine-agnostic logic (the JS-compat
+# value helpers, array/string methods, hydration markers). Everything that is
+# specific to *how a template is rendered* — JSON marshalling, raw-string
+# marking, JSX-children materialisation, and named-template rendering — lives
+# behind this backend object so the same runtime can drive a different Perl
+# template engine (Text::Xslate, Template Toolkit, …) without rewriting the
+# helper surface.
+#
+# A backend MUST implement:
+#   - encode_json($data)            -> string
+#   - mark_raw($str)                -> value the engine emits without escaping
+#   - materialize($value)           -> string (resolve a captured-children ref)
+#   - render_named($name, $bf, \%vars) -> string
+#
+# This Mojo implementation is the reference. To target another engine, write a
+# sibling backend (BarefootJS::Backend::Xslate, …) implementing the same four
+# methods and pass it via `BarefootJS->new($c, { backend => $b })`.
+
+# The Mojolicious controller. Optional: the value-marshalling helpers
+# (`encode_json` / `mark_raw` / `materialize`) work without it; only
+# `render_named` reaches into the controller's renderer + stash.
+has 'c';
+
+# Pluggable JSON encoder (#engine-abstraction). Defaults to
+# `Mojo::JSON::to_json`, which returns a *character* string (not bytes)
+# suitable for embedding in HTML output via `<%==` / Mojo::ByteStream.
+#
+# Override with any `sub ($data) { ... }` to swap in a faster XS encoder —
+# e.g. `json_encoder => sub { Cpanel::JSON::XS->new->canonical->encode($_[0]) }`.
+# The pure-Perl JSON::PP fallback Mojo::JSON uses can be a hot spot for large
+# props payloads; the seam lets a host pick its own implementation without
+# touching the runtime.
+has 'json_encoder' => sub { \&to_json };
+
+# Hold the controller weakly for the same reason BarefootJS does: the
+# controller owns the bf instance (which owns this backend) via its stash,
+# so a strong back-reference would close a per-request cycle the refcount GC
+# can't reclaim. `render_named` only touches `$self->c` mid-render, while the
+# controller is still alive on the request stack.
+sub new ($class, %args) {
+    my $self = $class->SUPER::new(%args);
+    weaken($self->{c}) if $self->{c};
+    return $self;
+}
+
+sub encode_json ($self, $data) {
+    return $self->json_encoder->($data);
+}
+
+# Mark a string as already-safe so the template engine emits it verbatim
+# (no re-escaping). In Mojo this is a Mojo::ByteStream, which the calling
+# template's `<%==` raw-emit passes through unescaped.
+sub mark_raw ($self, $str) {
+    return b($str);
+}
+
+# JSX children / async fallbacks arrive via Mojo's `begin %>...<% end`
+# capture, which produces a CODE ref returning a Mojo::ByteStream. Resolve
+# it to a string before embedding. Plain (already-rendered) strings pass
+# through unchanged.
+sub materialize ($self, $value) {
+    return ref($value) eq 'CODE' ? $value->() : $value;
+}
+
+# Render a named template with `$child_bf` bound as the active runtime
+# instance for that render. The Mojo `bf` helper resolves the current
+# instance off `$c->stash->{'bf.instance'}`; swap it for the duration of
+# the nested render and restore it afterwards so sibling renders are
+# unaffected.
+sub render_named ($self, $template_name, $child_bf, $vars) {
+    my $c = $self->c;
+    my $prev = $c->stash->{'bf.instance'};
+    $c->stash->{'bf.instance'} = $child_bf;
+    my $html = $c->render_to_string(template => $template_name, %$vars);
+    $c->stash->{'bf.instance'} = $prev;
+    return $html;
+}
+
+1;

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

@@ -1,4 +1,5 @@
 package Mojolicious::Plugin::BarefootJS::DevReload;
+our $VERSION = "0.01";
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 =head1 NAME
@@ -29,21 +30,12 @@ C<< enabled => 1 >> to force-enable.
 use Mojo::ByteStream qw(b);
 use Mojo::IOLoop;
 use File::Spec;
+use BarefootJS::DevReload ();
 
-# Sentinel path contract with @barefootjs/cli (DEV_SENTINEL_SUBDIR /
-# DEV_SENTINEL_FILENAME in packages/cli/src/lib/build.ts). Duplicated so this
-# package avoids a runtime dep on the CLI — keep in sync with the CLI.
-my $DEV_SUBDIR         = '.dev';
-my $BUILD_ID_FILE      = 'build-id';
-my $SCROLL_STORAGE_KEY = '__bf_devreload_scroll';
-
-# Heartbeat < any reasonable proxy/IOLoop idle timeout so a quiet connection
-# doesn't get reaped between rebuilds.
-my $HEARTBEAT_S = 5;
-
-# Polling instead of Linux::Inotify2 / Mac::FSEvents keeps the runtime
-# dependency-free. Sub-second latency is imperceptible next to browser reload.
-my $POLL_S = 0.5;
+# Engine-agnostic snippet, build-id reading, and timing constants are shared
+# with the PSGI/Plack path in BarefootJS::DevReload — one source of truth.
+my $HEARTBEAT_S = $BarefootJS::DevReload::HEARTBEAT_S;
+my $POLL_S      = $BarefootJS::DevReload::POLL_S;
 
 sub register ($self, $app, $config = {}) {
     my $dist_dir = $config->{dist_dir} // 'dist';
@@ -56,7 +48,7 @@ sub register ($self, $app, $config = {}) {
     # on mode — it simply returns an empty ByteStream when disabled.
     $app->helper(bf_dev_snippet => sub ($c) {
         return b('') unless $enabled;
-        return b(_snippet($endpoint));
+        return b(BarefootJS::DevReload->snippet($endpoint));
     });
 
     return unless $enabled;
@@ -67,9 +59,8 @@ sub register ($self, $app, $config = {}) {
     my $dist_abs = File::Spec->file_name_is_absolute($dist_dir)
         ? $dist_dir
         : $app->home->child($dist_dir)->to_string;
-    my $dev_dir       = File::Spec->catdir($dist_abs, $DEV_SUBDIR);
-    my $build_id_path = File::Spec->catfile($dev_dir, $BUILD_ID_FILE);
-    mkdir $dev_dir unless -d $dev_dir;
+    BarefootJS::DevReload->ensure_dev_dir($dist_abs);
+    my $build_id_path = BarefootJS::DevReload->build_id_path($dist_abs);
 
     $app->routes->get($endpoint => sub ($c) {
         my $last_event_id = $c->req->headers->header('Last-Event-ID') // '';
@@ -82,7 +73,7 @@ sub register ($self, $app, $config = {}) {
 
         $c->write("retry: 1000\n\n");
 
-        my $initial_id = _read_build_id($build_id_path);
+        my $initial_id = BarefootJS::DevReload->read_build_id($build_id_path);
         my $last_sent  = '';
         if (length $initial_id) {
             $last_sent = $initial_id;
@@ -105,7 +96,7 @@ sub register ($self, $app, $config = {}) {
             $c->write(": hb\n\n");
         });
         $poll_id = Mojo::IOLoop->recurring($POLL_S => sub {
-            my $id = _read_build_id($build_id_path);
+            my $id = BarefootJS::DevReload->read_build_id($build_id_path);
             return unless length $id;
             return if $id eq $last_sent;
             $last_sent = $id;
@@ -116,35 +107,4 @@ sub register ($self, $app, $config = {}) {
     return;
 }
 
-sub _read_build_id ($path) {
-    return '' unless -f $path;
-    open my $fh, '<', $path or return '';
-    local $/;
-    my $content = <$fh>;
-    close $fh;
-    $content //= '';
-    $content =~ s/^\s+|\s+$//g;
-    return $content;
-}
-
-sub _snippet ($endpoint) {
-    my $ep = _js_str($endpoint);
-    my $sk = _js_str($SCROLL_STORAGE_KEY);
-    # Small IIFE: EventSource subscriber + scrollY preservation. Idempotent
-    # across duplicate mounts (window.__bfDevReload guard).
-    return qq{<script>(function(){if(window.__bfDevReload)return;window.__bfDevReload=1;try{var s=sessionStorage.getItem($sk);if(s){sessionStorage.removeItem($sk);var y=parseInt(s,10);if(!isNaN(y)){var restore=function(){window.scrollTo(0,y)};if(document.readyState==='loading'){addEventListener('DOMContentLoaded',restore,{once:true})}else{restore()}}}}catch(e){}var es=new EventSource($ep);es.addEventListener('reload',function(){try{sessionStorage.setItem($sk,String(window.scrollY))}catch(e){}location.reload()});es.addEventListener('error',function(){})})();</script>};
-}
-
-sub _js_str ($s) {
-    # Minimal JS string escape for the handful of characters that can appear
-    # in a URL path or storage key. Good enough for package-internal + trusted
-    # operator-supplied strings; never interpolate untrusted input here.
-    my $t = $s;
-    $t =~ s/\\/\\\\/g;
-    $t =~ s/"/\\"/g;
-    $t =~ s/\n/\\n/g;
-    $t =~ s/\r/\\r/g;
-    return qq{"$t"};
-}
-
 1;

package/lib/Mojolicious/Plugin/BarefootJS.pm

@@ -1,4 +1,5 @@
 package Mojolicious::Plugin::BarefootJS;
+our $VERSION = "0.01";
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 use Mojo::File qw(path);
@@ -102,3 +103,58 @@ sub _load_manifest ($app, $config) {
 }
 
 1;
+__END__
+
+=encoding utf8
+
+=head1 NAME
+
+Mojolicious::Plugin::BarefootJS - Mojolicious integration for BarefootJS
+
+=head1 SYNOPSIS
+
+    # Mojolicious application
+    $self->plugin('BarefootJS');
+
+    # In a controller / template, the `bf` helper exposes a per-request
+    # BarefootJS runtime backed by BarefootJS::Backend::Mojo.
+
+=head1 DESCRIPTION
+
+Wires the L<BarefootJS> server runtime into L<Mojolicious>. It registers a
+C<bf> controller helper that lazily instantiates one BarefootJS object per
+request (rendering via L<BarefootJS::Backend::Mojo>), and supports rendering
+compiled marked templates as Mojolicious templates.
+
+For non-Mojolicious / PSGI hosts, see L<BarefootJS::Backend::Xslate>, which
+drives the same runtime with Text::Xslate and no web framework.
+
+=head1 METHODS
+
+L<Mojolicious::Plugin::BarefootJS> inherits all methods from
+L<Mojolicious::Plugin> and implements the following new one.
+
+=head2 register
+
+    $plugin->register(Mojolicious->new, \%conf);
+
+Registers the plugin (the C<bf> helper and supporting hooks) in a Mojolicious
+application.
+
+=head1 SEE ALSO
+
+L<BarefootJS>, L<BarefootJS::Backend::Mojo>, L<BarefootJS::Backend::Xslate>,
+L<Mojolicious>, L<https://github.com/piconic-ai/barefootjs>
+
+=head1 AUTHOR
+
+kobaken E<lt>kentafly88@gmail.comE<gt>
+
+=head1 LICENSE
+
+Copyright (c) 2025-present BarefootJS Contributors.
+
+This library is free software; you can redistribute it and/or modify it under
+the MIT License. See the F<LICENSE> file in the distribution for the full text.
+
+=cut

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/mojolicious",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "Mojolicious EP template adapter for BarefootJS - generates .html.ep files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -29,7 +29,7 @@
   ],
   "scripts": {
     "build": "bun run build:js && bun run build:types",
-    "build:js": "bun build ./src/index.ts ./src/adapter/index.ts ./src/build.ts --root ./src --outdir ./dist --format esm --external @barefootjs/jsx --external @barefootjs/shared",
+    "build:js": "bun build ./src/index.ts ./src/adapter/index.ts ./src/build.ts --root ./src --outdir ./dist --format esm --external @barefootjs/jsx --external @barefootjs/shared --external typescript",
     "build:types": "tsgo --emitDeclarationOnly --outDir ./dist",
     "test": "bun test",
     "clean": "rm -rf dist",
@@ -52,14 +52,15 @@
     "directory": "packages/adapter-mojolicious"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.6.1"
+    "@barefootjs/perl": "0.8.0",
+    "@barefootjs/shared": "0.8.0"
   },
   "peerDependencies": {
-    "@barefootjs/jsx": ">=0.2.0"
+    "@barefootjs/jsx": ">=0.2.0",
+    "typescript": "^5.0.0"
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.6.1",
-    "typescript": "^5.0.0"
+    "@barefootjs/jsx": "0.8.0"
   }
 }

package/src/__tests__/mojo-adapter.test.ts

@@ -69,16 +69,24 @@ runAdapterConformanceTests({
     'toggle-shared',
     'reactive-props',
     'props-reactivity-comparison',
-    // #1467 Phase 2a: first `site/ui` source-root fixture. Button
-    // compiles cleanly on the Mojo adapter (no diagnostic), but its
-    // variant/size class composition (`Record<…>[key]` indexed object
-    // literals) and `applyRestAttrs` spread haven't been validated for
-    // byte-parity against the Hono reference under Mojo's template
-    // semantics. Cross-adapter parity for the `site/ui` corpus is
-    // explicitly Phase 3 ("cross-adapter parity (Mojo/Go templates)"),
-    // so Button participates only in Hono SSR conformance + the
-    // fixture-hydrate runtime layer for now.
-    'button',
+    // #1467 Phase 2b: basic interactive `site/ui` primitives. Cross-adapter
+    // parity for the `site/ui` corpus is Phase 3, so these participate only
+    // in Hono SSR conformance + the fixture-hydrate runtime layer for now.
+    // (`label` and `kbd` are static helpers; `toggle` / `switch` /
+    // `checkbox` carry uncontrolled state; `input` is a pass-through
+    // native control.)
+    //
+    // `textarea` now participates: its conditional inline-object spread
+    // (`{...(describedBy ? {...} : {})}`) lowers via
+    // `conditionalSpreadToPerl`, and its optional `rows={rows}`
+    // attribute is omitted when `undef` via the `defined`-guard in
+    // `elementAttrEmitter.emitExpression`
+    // (`<% if (defined $rows) { %>rows="<%= $rows %>"<% } %>`), matching
+    // Hono's nullish-attribute omission.
+    'toggle',
+    'switch',
+    'checkbox',
+    'kbd',
   ],
   // Per-fixture build-time contracts for shapes the Mojo adapter
   // intentionally refuses to lower. Owned by this adapter test file
@@ -239,6 +247,76 @@ function compileAndGenerate(source: string, adapter?: MojoAdapter) {
 // Mojo-Specific Tests
 // =============================================================================
 
+describe('MojoAdapter - conditional inline-object spread (textarea aria-describedby)', () => {
+  // `{...(cond ? { 'aria-describedby': cond } : {})}` lowers to a Perl
+  // inline ternary of hashrefs so the falsy `{}` branch OMITS the key
+  // (bf->spread_attrs does not filter empty strings). The shared
+  // fixture only exercises the falsy branch; this pins the truthy one.
+  test('emits a Perl inline ternary of hashrefs through bf->spread_attrs', () => {
+    const { template } = compileAndGenerate(`
+function Box({ describedBy }: { describedBy?: string }) {
+  return <div {...(describedBy ? { 'aria-describedby': describedBy } : {})} />
+}
+`)
+    expect(template).toContain(
+      "bf->spread_attrs($describedBy ? { 'aria-describedby' => $describedBy } : {})",
+    )
+  })
+
+  test('resolves the value reference and preserves the static key for a second prop', () => {
+    const { template } = compileAndGenerate(`
+function Box({ label }: { label: string }) {
+  return <div {...(label ? { 'data-label': label } : {})} />
+}
+`)
+    expect(template).toContain(
+      "bf->spread_attrs($label ? { 'data-label' => $label } : {})",
+    )
+  })
+
+  test('falls back to BF101 for a computed (non-static) object key', () => {
+    const adapter = new MojoAdapter()
+    const ir = compileToIR(`
+function Box({ k, v }: { k?: string; v?: string }) {
+  return <div {...(v ? { [k]: v } : {})} />
+}
+`, adapter)
+    adapter.generate(ir)
+    const errs = (adapter as unknown as { errors: { code: string }[] }).errors
+    expect(errs.some(e => e.code === 'BF101')).toBe(true)
+  })
+})
+
+describe('MojoAdapter - nullish optional-attribute omission (textarea rows)', () => {
+  // A no-destructure-default, nillable-typed prop is `undef` when the
+  // caller omits it; guard its bare-reference attribute with Perl
+  // `defined` so it DROPS instead of rendering `attr=""` — matching
+  // Hono's nullish-attribute omission. Concrete/defaulted props are
+  // never `undef` and stay unconditional.
+  test('guards a no-default nillable attr with a Perl defined check', () => {
+    const { template } = compileAndGenerate(`
+function C({ rows }: { rows?: number }) {
+  return <textarea rows={rows} />
+}
+`)
+    expect(template).toContain('<% if (defined $rows) { %>rows="<%= $rows %>"<% } %>')
+    // Must NOT emit the bare unconditional form.
+    expect(template).not.toMatch(/(?<!\{ %>)rows="<%= \$rows %>"/)
+  })
+
+  test('leaves a defaulted attr unconditional (scope did not widen)', () => {
+    const { template } = compileAndGenerate(`
+function C({ value = '' }: { value?: string }) {
+  return <textarea value={value} />
+}
+`)
+    // `value` has a destructure default → never undef → unconditional,
+    // exactly like Hono's value="".
+    expect(template).toContain('value="<%= $value %>"')
+    expect(template).not.toContain('defined $value')
+  })
+})
+
 describe('MojoAdapter - Template Generation', () => {
   test('generates basic element with scope marker', () => {
     const result = compileAndGenerate(`
@@ -256,6 +334,42 @@ export function Hello() {
     expect(adapter.extension).toBe('.html.ep')
   })
 
+  test('module pure-string const referenced in className inlines the literal (#1467 Phase 2b)', () => {
+    // A module-scope `const X = 'literal'` used inside a className template
+    // literal must inline its value, NOT emit `$X` against a stash variable
+    // that is never bound (the value would render empty). Hono inlines it at
+    // runtime; this restores byte-parity.
+    const result = compileAndGenerate(`
+"use client"
+const labelClasses = 'flex items-center group-data-[disabled=true]:opacity-50'
+export function Label({ className = '' }: { className?: string }) {
+  return <label className={\`\${labelClasses} \${className}\`} />
+}
+`)
+    // Inlined as a Perl single-quoted literal, escaped tokens intact.
+    expect(result.template).toContain(
+      "'flex items-center group-data-[disabled=true]:opacity-50'",
+    )
+    // No stash-variable reference to the const.
+    expect(result.template).not.toContain('$labelClasses')
+  })
+
+  test('module pure-string const is NOT inlined when shadowed by a loop variable (#1749 review)', () => {
+    // A loop param whose name matches a module const must keep its loop
+    // binding (`$label`) inside the body — the const literal must not leak
+    // in. `renderLoop` guards module-const inlining for the loop body.
+    const result = compileAndGenerate(`
+"use client"
+const label = 'MODULE_CONST'
+export function List({ items }: { items: string[] }) {
+  return <ul>{items.map(label => <li>{label}</li>)}</ul>
+}
+`)
+    // Inside the loop the param wins — emit the loop variable, not the const.
+    expect(result.template).toContain('$label')
+    expect(result.template).not.toContain('MODULE_CONST')
+  })
+
   test('generates conditional with Perl if/else', () => {
     const result = compileAndGenerate(`
 "use client"