@barefootjs/mojolicious 0.7.0 → 0.9.0

package/src/adapter/mojo-adapter.ts

@@ -47,6 +47,9 @@ import {
   emitParsedExpr,
   emitIRNode,
   emitAttrValue,
+  augmentInheritedPropAccesses,
+  parseRecordIndexAccess,
+  evalStringArrayJoin,
 } from '@barefootjs/jsx'
 import { isAriaBooleanAttr, isBooleanResultExpr } from './boolean-result'
 
@@ -142,7 +145,20 @@ function parsePureStringLiteral(source: string): string | null {
   if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) {
     return init.text
   }
-  return null
+  // `[<literals>].join(' ')` module consts (e.g. Switch's `trackStateClasses`)
+  // → inline the flattened string byte-for-byte. See `evalStringArrayJoin`.
+  return evalStringArrayJoin(source)
+}
+
+/**
+ * (#checkbox) Quote a `render_child` named-arg / hashref key when it isn't a
+ * bare Perl identifier. A JSX attribute name like `data-slot` would otherwise
+ * emit `data-slot => '...'`, which Perl parses as the subtraction
+ * `data - slot`. Identifier-safe names (`className`, `size`, `_bf_slot`) pass
+ * through unquoted to keep the generated template readable.
+ */
+function perlHashKey(name: string): string {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : `'${name.replace(/'/g, "\\'")}'`
 }
 
 export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRenderCtx> {
@@ -198,6 +214,14 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
    * module-scope pure string literals qualify (see `collectModuleStringConsts`).
    */
   private moduleStringConsts: Map<string, string> = new Map()
+  /**
+   * Full local-constant metadata from the entry IR, kept so spread
+   * lowering can resolve a bare-identifier spread (`{...sizeAttrs}`) to
+   * its initializer text and a `Record[propKey]` spread value to the
+   * module-const object literal it indexes (#checkbox / icon). Populated
+   * at `generate()` entry alongside `moduleStringConsts`.
+   */
+  private localConstants: IRMetadata['localConstants'] = []
   /**
    * Names currently bound by an enclosing loop body — the `my $<param>` and
    * `my $<index>` bindings `renderLoop` introduces — ref-counted so nested
@@ -207,6 +231,23 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
    * 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()
@@ -219,7 +260,40 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
   generate(ir: ComponentIR, options?: AdapterGenerateOptions): AdapterOutput {
     this.componentName = ir.metadata.componentName
     this.propsObjectName = ir.metadata.propsObjectName ?? null
+    // (#checkbox) Enumerate inherited-attribute accesses for the props-object
+    // pattern (`function Checkbox(props: CheckboxProps)`) before deriving
+    // `nullableOptionalProps`, so a bare optional attribute like
+    // `id={props.id}` gets the Perl `defined`-guard (Hono-style omission).
+    // Shared with the Go adapter (single source of truth in `@barefootjs/jsx`).
+    // The harness separately declares the matching stash vars (Pass-1 IR
+    // serialization happens before `generate`, so this mutation doesn't reach it).
+    augmentInheritedPropAccesses(ir)
     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
@@ -235,6 +309,7 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
       if (isStringTypeInfo(p.type)) this.stringValueNames.add(p.name)
     }
     this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants)
+    this.localConstants = ir.metadata.localConstants ?? []
     this.loopBoundNames.clear()
     this.errors = []
     this.childrenCaptureCounter = 0
@@ -766,7 +841,7 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
    * `render_child` named-arg list.
    */
   private readonly componentPropEmitter: AttrValueEmitter = {
-    emitLiteral: (value, name) => `${name} => '${value.value}'`,
+    emitLiteral: (value, name) => `${perlHashKey(name)} => '${value.value}'`,
     emitExpression: (value, name) => {
       // The IR producer collapses component-prop `template` kinds
       // into `expression` for client-runtime reasons but preserves
@@ -775,9 +850,9 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
       // `${MAP[KEY]}` shapes (the JS object literal leaks into the
       // Perl template).
       if (value.parts) {
-        return `${name} => ${this.convertTemplateLiteralPartsToPerl(value.parts)}`
+        return `${perlHashKey(name)} => ${this.convertTemplateLiteralPartsToPerl(value.parts)}`
       }
-      return `${name} => ${this.convertExpressionToPerl(value.expr)}`
+      return `${perlHashKey(name)} => ${this.convertExpressionToPerl(value.expr)}`
     },
     emitSpread: (value) => {
       // Perl has no JS-style spread — emit the source as a hash
@@ -790,9 +865,9 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
       return perlExpr.startsWith('%') ? perlExpr : `%{${perlExpr}}`
     },
     emitTemplate: (value, name) =>
-      `${name} => ${this.convertTemplateLiteralPartsToPerl(value.parts)}`,
-    emitBooleanAttr: (_value, name) => `${name} => 1`,
-    emitBooleanShorthand: (_value, name) => `${name} => 1`,
+      `${perlHashKey(name)} => ${this.convertTemplateLiteralPartsToPerl(value.parts)}`,
+    emitBooleanAttr: (_value, name) => `${perlHashKey(name)} => 1`,
+    emitBooleanShorthand: (_value, name) => `${perlHashKey(name)} => 1`,
     // JSX children flow through Mojo's `begin %>…<% end` capture
     // below; they're not part of the named-arg list.
     emitJsxChildren: () => '',
@@ -935,6 +1010,41 @@ 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()
+      // Normalize a props-object access (`props.id`) to its bare prop name
+      // (`id`) so the nullable-optional set — keyed by bare name — matches the
+      // SolidJS props-object pattern, not just destructured params (#checkbox
+      // `id={props.id}`).
+      const normalizedBareId =
+        this.propsObjectName && bareId.startsWith(`${this.propsObjectName}.`)
+          ? bareId.slice(this.propsObjectName.length + 1)
+          : bareId
+      if (
+        !isBooleanAttr(name) &&
+        !value.presenceOrUndefined &&
+        /^[A-Za-z_$][\w$]*$/.test(normalizedBareId) &&
+        this.nullableOptionalProps.has(normalizedBareId)
+      ) {
+        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}' : '' %>`
@@ -1008,6 +1118,37 @@ 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}) %>`
+      }
+      // Function-scope local const holding a conditional inline-object
+      //   `const sizeAttrs = size ? {…} : {}` then `{...sizeAttrs}`
+      // (#checkbox / icon). Resolve the bare identifier to its
+      // initializer text and route through the same conditional-spread
+      // lowering. Only function-scope (`!isModule`) consts whose value is
+      // NOT itself a bare identifier (loop guard) are considered.
+      if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(trimmed)) {
+        const localConst = this.localConstants.find(
+          c => c.name === trimmed && !c.isModule,
+        )
+        if (localConst?.value !== undefined) {
+          const initTrimmed = localConst.value.trim()
+          if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(initTrimmed)) {
+            const resolved = this.conditionalSpreadToPerl(initTrimmed)
+            if (resolved !== null) {
+              return `<%== bf->spread_attrs(${resolved}) %>`
+            }
+          }
+        }
+      }
       const perlExpr = this.convertExpressionToPerl(value.expr)
       return `<%== bf->spread_attrs(${perlExpr}) %>`
     },
@@ -1294,6 +1435,114 @@ 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 initNode = (() => {
+        let n: ts.Expression = prop.initializer
+        while (ts.isParenthesizedExpression(n)) n = n.expression
+        return n
+      })()
+      const indexed = this.recordIndexAccessToPerl(initNode)
+      const valPerl =
+        indexed !== null
+          ? indexed
+          : this.convertExpressionToPerl(prop.initializer.getText(sf))
+      entries.push(`'${key.replace(/'/g, "\\'")}' => ${valPerl}`)
+    }
+    return entries.length === 0 ? '{}' : `{ ${entries.join(', ')} }`
+  }
+
+  /**
+   * Lower a spread-object VALUE of the form `IDENT[KEY]` where:
+   *   - `IDENT` resolves via `localConstants` to a MODULE-scope object
+   *     literal whose property values are all scalar (number/string)
+   *     literals under static (string-literal or identifier) keys
+   *     (a `Record<staticKeys, scalar>` map like `sizeMap`), AND
+   *   - `KEY` is a bare identifier that is a prop.
+   * Emits an inline indexed Perl hashref:
+   *   `{ 'sm' => 16, 'md' => 20, ... }->{$size}`
+   *
+   * Returns the Perl string when convertible, else `null` so the caller
+   * falls back to its normal value lowering (which records BF101 for an
+   * unsupported shape). Mirror of the Go adapter's `recordIndexAccessToGoMap`.
+   */
+  private recordIndexAccessToPerl(val: ts.Expression): string | null {
+    // Shared structural parse (single source of truth in `@barefootjs/jsx`);
+    // this wrapper only does the Perl-specific emit (single-quote escaping)
+    // from the structured result.
+    const parsed = parseRecordIndexAccess(val, this.localConstants, this.propsParams)
+    if (!parsed) return null
+    const entries = parsed.entries.map(e => {
+      const mapVal =
+        e.value.kind === 'number' ? e.value.text : `'${e.value.text.replace(/'/g, "\\'")}'`
+      return `'${e.key.replace(/'/g, "\\'")}' => ${mapVal}`
+    })
+    return `{ ${entries.join(', ')} }->{$${parsed.indexPropName}}`
+  }
+
+
   private convertExpressionToPerl(expr: string): string {
     // Parse-first lowering — parity with the Go adapter's
     // `convertExpressionToGo`. Parse the JS expression once, gate it on

package/src/test-render.ts

@@ -349,7 +349,12 @@ function buildChildRenderers(
     }
     lines.push(`    ${slotIdsPerl}`)
     lines.push(`    my $child_bf = BarefootJS->new($c, {});`)
-    lines.push(`    $child_bf->_scope_id("test_$sid");`)
+    // Child scope id derives from the PARENT's live scope id, not a literal
+    // `test_` prefix — so `<ReactiveProps_test>_s5` matches Hono / CSR (and
+    // survives an explicit `__instanceId`). Mirrors xslate's
+    // `rootChildScopePrefix` (`$bf->_scope_id`); `$bf` is the parent instance
+    // captured by this renderer closure.
+    lines.push(`    $child_bf->_scope_id($bf->_scope_id . "_$sid");`)
     lines.push(`    my $rendered = $child_mt->render($child_tmpl, { %$child_props, bf => $child_bf });`)
     lines.push(`    die $rendered->to_string if ref $rendered;`)
     lines.push(`    chomp $rendered;`)
@@ -433,6 +438,26 @@ function buildPerlProps(
     entries.push(`${param.name} => undef`)
   }
 
+  // (#checkbox) SolidJS props-object pattern: `function Checkbox(props:
+  // CheckboxProps)` only enumerates `CheckboxProps`'s own members in
+  // `propsParams`; inherited `ButtonHTMLAttributes` members the component
+  // reads as bare template vars (`$id`, `$disabled`, `$className`) are not.
+  // The generated template references them, so the stash must declare them or
+  // Perl strict mode aborts with `Global symbol "$id" requires explicit
+  // package name`. Scan the IR for `props.<name>` accesses and seed any not
+  // already declared (and not supplied by the caller below) as `undef`.
+  // Mirrors the Go adapter's `augmentInheritedPropAccesses`.
+  if (ir.metadata.propsObjectName) {
+    const propsObj = ir.metadata.propsObjectName
+    const declared = new Set(ir.metadata.propsParams.map(p => p.name))
+    for (const name of collectPropsObjectAccesses(ir, propsObj)) {
+      if (declared.has(name)) continue
+      if (props && name in props) continue // emitted by the user-props loop
+      entries.push(`${name} => undef`)
+      declared.add(name)
+    }
+  }
+
   // 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
@@ -524,6 +549,38 @@ function buildPerlProps(
   return `{${entries.join(', ')}}`
 }
 
+/**
+ * (#checkbox) Collect `<propsObj>.<name>` accesses across a component's memos,
+ * signal initializers, init statements, and template attribute expressions —
+ * the inherited-attribute reads (`props.className`, `props.id`, `props.disabled`)
+ * a SolidJS props-object component makes but that aren't enumerated in
+ * `propsParams`. Used to declare matching stash variables.
+ */
+function collectPropsObjectAccesses(ir: ComponentIR, propsObj: string): Set<string> {
+  const out = new Set<string>()
+  const re = new RegExp(`(?:^|[^\\w$.])${propsObj}\\.([A-Za-z_$][\\w$]*)`, 'g')
+  const scan = (s: string | undefined): void => {
+    if (!s) return
+    for (const m of s.matchAll(re)) out.add(m[1])
+  }
+  for (const memo of ir.metadata.memos) scan(memo.computation)
+  for (const sig of ir.metadata.signals) scan(sig.initialValue)
+  for (const stmt of ir.metadata.initStatements ?? []) scan(stmt.body)
+  const walk = (node: unknown): void => {
+    if (!node || typeof node !== 'object') return
+    const el = node as { attrs?: Array<{ value?: { kind?: string; expr?: string } }>; children?: unknown[] }
+    for (const attr of el.attrs ?? []) {
+      if (attr.value?.kind === 'expression') scan(attr.value.expr)
+    }
+    for (const child of el.children ?? []) {
+      const c = child as { element?: unknown }
+      walk(c.element ?? child)
+    }
+  }
+  walk(ir.root)
+  return out
+}
+
 /**
  * Evaluate a signal initializer expression using provided props.
  * Handles patterns like: props.initial ?? 0, props.value, literal values.