@barefootjs/mojolicious 0.18.4 → 0.18.7

package/src/adapter/props/prop-classes.ts

@@ -7,7 +7,7 @@
  * adapter's `props/prop-types.ts`. No adapter instance state.
  */
 
-import type { ComponentIR } from '@barefootjs/jsx'
+import { collectLoopBoundNames, type ComponentIR } from '@barefootjs/jsx'
 import { isStringTypeInfo, isBareStringLiteral } from '../value/parsed-literal.ts'
 
 /**
@@ -67,11 +67,28 @@ export function collectNullableOptionalProps(ir: ComponentIR): Set<string> {
 }
 
 /**
- * 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 initial value) or,
- * defensively, when its initial value is a bare string literal; a prop when
- * its annotated type is `string`.
+ * String-typed signals, props, and same-file local consts, so equality
+ * comparisons against them lower to `eq`/`ne` (#1672) and `+` concatenation
+ * against them lowers to Perl's `.` instead of numeric `+` (#2163, #2212 —
+ * `isStringConcatBinary`/`isStringTypedOperand` in `@barefootjs/jsx`, which
+ * now also recognizes a bare identifier operand, not just a prop/getter/
+ * literal). A signal is string-typed when its inferred type is `string`
+ * (the analyzer infers this from a string-literal initial value) or,
+ * defensively, when its initial value is a bare string literal; a prop or
+ * local const when its annotated (or inferred) type is `string`.
+ *
+ * Excludes any name bound as a `.map()`/`.filter()` loop callback's item
+ * or index parameter ANYWHERE in the component (Fable review, #2212): the
+ * lookup below is a flat, scope-blind `Set<string>` with no notion of a
+ * loop param shadowing an outer string-typed binding of the same name
+ * (`items.map((name) => 1 + name)` inside a component that also has a
+ * string `name` prop) — left unguarded, that shadowed `name` would be
+ * misdetected as string-typed and `1 + name` would silently lower to `.`
+ * instead of staying numeric `+`. Subtracting loop-bound names is coarse
+ * (it also suppresses a genuinely non-shadowed same-named string
+ * elsewhere in the component) but safe: the suppressed case just falls
+ * back to today's numeric `+` — the same, already-accepted residual as an
+ * unresolvable operand — never silently-wrong output.
  */
 export function collectStringValueNames(ir: ComponentIR): Set<string> {
   const names = new Set<string>()
@@ -83,5 +100,9 @@ export function collectStringValueNames(ir: ComponentIR): Set<string> {
   for (const p of ir.metadata.propsParams) {
     if (isStringTypeInfo(p.type)) names.add(p.name)
   }
+  for (const c of ir.metadata.localConstants) {
+    if (isStringTypeInfo(c.type ?? undefined) || isBareStringLiteral(c.value)) names.add(c.name)
+  }
+  for (const bound of collectLoopBoundNames(ir)) names.delete(bound)
   return names
 }

package/src/conformance-pins.ts

@@ -9,17 +9,17 @@
 import type { ConformancePins } from '@barefootjs/jsx'
 
 export const conformancePins: ConformancePins = {
-  // Sibling-imported child component in a loop body: Mojo emits
-  // a cross-template call that needs separate registration. BF103
-  // makes the requirement loud. (The barefoot CLI passes
-  // `siblingTemplatesRegistered: true` so CLI builds suppress it.)
-  'static-array-children': [{ code: 'BF103', severity: 'error' }],
-  // TodoApp / TodoAppSSR import `TodoItem` from a sibling file and
-  // call it inside a keyed `.map`. Same BF103 surface as the
-  // synthetic `static-array-children` above — pinned at adapter
-  // level so the shared-component corpus stays adapter-neutral.
-  'todo-app': [{ code: 'BF103', severity: 'error' }],
-  'todo-app-ssr': [{ code: 'BF103', severity: 'error' }],
+  // `todo-app` / `todo-app-ssr` no longer pinned (#2205) — the conformance
+  // harness now passes `siblingTemplatesRegistered: true` for fixtures with
+  // sibling `components`, matching `bf build`'s real semantics, so the
+  // BF103 loop-body cross-template check no longer fires spuriously. (Both
+  // fixtures are still skipped on this adapter via `render-divergences.ts`
+  // — #2209 — for an unrelated signal-seeding gap.)
+  // `static-array-children` no longer pinned (#2208) — `items`'s
+  // array-literal initializer is now recognized as fully-static
+  // (`resolveStaticLoopSource`) and inlined as a native Perl
+  // arrayref/hashref literal in the loop-bound expression, the same way a
+  // module-scope const's value is already seeded.
   // `([emoji, users]) => ...` / `([id, t]) => ...` are plain array-index
   // (tuple) destructures, no rest — #2087 Phase B's `segments`-walking
   // accessor lowers both to `$__bf_item->[0]` / `$__bf_item->[1]` `my`
@@ -32,12 +32,11 @@ export const conformancePins: ConformancePins = {
   // check in `renderLoop`. This was always true; it was simply
   // unreachable before because BF104 refused the destructure shape first.
   'static-array-from-props': [{ code: 'BF101', severity: 'error' }],
-  // Both BF103 (sibling-imported `<Tag>` child component) and the BF101
-  // above fire; BF104 no longer does (see above).
-  'static-array-from-props-with-component': [
-    { code: 'BF103', severity: 'error' },
-    { code: 'BF101', severity: 'error' },
-  ],
+  // The BF101 above fires; BF104 no longer does (see above), and BF103
+  // (sibling-imported `<Tag>` child component in the loop body) no longer
+  // does either now that the conformance harness passes
+  // `siblingTemplatesRegistered: true` (#2205).
+  'static-array-from-props-with-component': [{ code: 'BF101', severity: 'error' }],
   // #1310 / #2087: rest destructure in .map() callback. All four shapes
   // now lower via #2087 Phase B's `segments`-walking accessor:
   //   - object-rest read via member access (`rest-destructure-object-in-map`):
@@ -130,20 +129,14 @@ export const conformancePins: ConformancePins = {
   // runtime `bf->find` / `find_index` / `find_last` / `find_last_index` helpers
   // (per-element coderef predicate), matching Xslate. `.join` was never
   // pinned (handled by `renderArrayMethod`'s `case 'join'`).
-  // #2073 follow-up: a function-reference `.map(format)` callback has no
-  // arrow body to serialize — not a CALLBACK_METHODS shape — so the
-  // UNSUPPORTED_METHODS gate refuses it with BF101 rather than emitting
-  // a broken template.
-  'array-map-function-reference': [{ code: 'BF101', severity: 'error' }],
-  // Edge-case sweep (Priority 12): `dangerouslySetInnerHTML` requires a
-  // deliberate raw-HTML (unescaped) output affordance in the target
-  // template language. No lowering exists yet, so the compiler refuses
-  // the shape loudly instead of emitting entity-escaped markup that
-  // silently renders tags as text.
-  'dangerous-inner-html': [{ code: 'BF101', severity: 'error' }],
-  // Edge-case sweep (Priority 12): `.replaceAll` has no lowering yet —
-  // only first-occurrence `.replace` is wired to the runtime helpers.
-  // Refused with BF101 rather than reusing the first-only lowering,
-  // which would silently change semantics.
-  'string-replaceall': [{ code: 'BF101', severity: 'error' }],
+  // `array-map-function-reference` no longer pinned — a bare-identifier
+  // `.map(format)` callback now resolves one hop to its declaration
+  // (`resolveCallbackMethodFunctionReferences`, #2206), the same mechanism
+  // #2090 established for `.sort(fnref)`.
+  // `dangerous-inner-html` no longer pinned — a compile-time string-literal
+  // `dangerouslySetInnerHTML={{ __html: '...' }}` is spliced directly into
+  // the template as trusted raw text (`resolveDangerousInnerHtml`, #2207).
+  // A dynamic/signal-derived value still refuses with BF101 — see the
+  // `dangerous-inner-html-dynamic` fixture/pin below (tracked: #2215).
+  'dangerous-inner-html-dynamic': [{ code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2215' }],
 }

package/src/render-divergences.ts

@@ -15,24 +15,8 @@
 import type { RenderDivergences } from '@barefootjs/jsx'
 
 export const renderDivergences: RenderDivergences = {
-  'string-length-text':
-    '`.length` on a STRING prop diverges (array-length lowering misapplied to a scalar)',
-  'number-tofixed':
-    'the literal `¥` in template text reaches the output as U+FFFD — a UTF-8 encoding gap for non-ASCII literal text adjacent to a dynamic slot',
-  'html-entity-text':
-    '`©` in JSX literal text: Hono decodes to `©`, this adapter re-emits the raw entity — same DOM, different bytes',
-  'math-methods':
-    'Math.min/max/abs over a signal render empty (only Math.floor is in the template-primitive registry)',
-  'static-attr-escape':
-    'static attribute values are not HTML-escaped (`title="Fish & Chips"` emitted raw; Hono escapes)',
-  'object-entries-map':
-    '`Object.entries(prop).map(([k, v]) => …)` renders an EMPTY list — the object-shaped prop silently produces zero iterations',
-  'nested-loop-outer-binding':
-    'nested-loop inner items carry `data-key` where the reference emits the depth-suffixed `data-key-1`',
-  'jsx-element-prop':
-    'a JSX element passed as a NON-children prop renders an empty slot — the element value is silently dropped',
-  'string-slice':
-    '`.slice()` on a STRING misfires through the array slice helper',
-  'string-trim-sided':
-    '`.trimStart()` / `.trimEnd()` render empty (no lowering)',
+  // `todo-app` / `todo-app-ssr` no longer diverge (#2209) — the shared
+  // `evaluateSignalInit` (`@barefootjs/jsx`, sandboxed real-JS evaluation
+  // instead of a fixed regex-shape catalogue) now correctly seeds `todos`
+  // from `(props.initialTodos ?? []).map(t => ({ ...t, editing: false }))`.
 }

package/src/test-render.ts

@@ -5,7 +5,7 @@
  * Used by adapter-tests conformance runner.
  */
 
-import { compileJSX, extractSsrDefaults, augmentInheritedPropAccesses, importsSearchParams } from '@barefootjs/jsx'
+import { compileJSX, extractSsrDefaults, augmentInheritedPropAccesses, importsSearchParams, evaluateSignalInit, tryEvaluateSignalInit } from '@barefootjs/jsx'
 import type { ComponentIR } from '@barefootjs/jsx'
 import { mkdir, rm } from 'node:fs/promises'
 import { resolve } from 'node:path'
@@ -136,8 +136,15 @@ export async function renderMojoComponent(options: RenderOptions): Promise<strin
     }
   }
 
-  // Compile parent source
-  const result = compileJSX(source, 'component.tsx', { adapter, outputIR: true })
+  // Compile parent source. `siblingTemplatesRegistered: Boolean(components)`
+  // matches this harness's real behavior — every sibling child template is registered
+  // alongside the parent before rendering, so a loop-body cross-template
+  // call resolves at render time (#2205).
+  const result = compileJSX(source, 'component.tsx', {
+    adapter,
+    outputIR: true,
+    siblingTemplatesRegistered: Boolean(components),
+  })
 
   const errors = result.errors.filter(e => e.severity === 'error')
   if (errors.length > 0) {
@@ -240,6 +247,11 @@ export async function renderMojoComponent(options: RenderOptions): Promise<strin
 use strict;
 use warnings;
 use utf8;
+# The template is read through :utf8, so $output holds decoded wide
+# characters; without a matching layer on STDOUT Perl emits them as
+# latin-1 bytes and the harness reads U+FFFD (©/¥ mangling). A real
+# Mojolicious response encodes on the way out — this is harness-only.
+binmode STDOUT, ':encoding(UTF-8)';
 
 use lib '${LIB_DIR}', '${PERL_CORE_LIB_DIR}';
 use Mojolicious;
@@ -445,9 +457,9 @@ function buildChildDefaultsPerl(ir: ComponentIR): string {
   for (const param of ir.metadata.propsParams) {
     declared.add(param.name)
     if (param.defaultValue) {
-      const perlValue = jsToPerlValue(param.defaultValue)
-      if (perlValue !== null) {
-        entries.push(`${param.name} => ${perlValue}`)
+      const result = tryEvaluateSignalInit(param.defaultValue.trim())
+      if (result.ok) {
+        entries.push(`${param.name} => ${toPerlLiteral(result.value)}`)
         continue
       }
     }
@@ -495,9 +507,9 @@ function buildPerlProps(
   for (const param of ir.metadata.propsParams) {
     if (props && param.name in props) continue
     if (param.defaultValue) {
-      const perlValue = jsToPerlValue(param.defaultValue)
-      if (perlValue !== null) {
-        entries.push(`${param.name} => ${perlValue}`)
+      const result = tryEvaluateSignalInit(param.defaultValue.trim(), props)
+      if (result.ok) {
+        entries.push(`${param.name} => ${toPerlLiteral(result.value)}`)
         continue
       }
     }
@@ -671,176 +683,6 @@ function collectPropsObjectAccesses(ir: ComponentIR, propsObj: string): Set<stri
   return out
 }
 
-/**
- * Evaluate a signal initializer expression using provided props.
- * Handles patterns like: props.initial ?? 0, props.value, literal values.
- */
-export function evaluateSignalInit(
-  expr: string,
-  props?: Record<string, unknown>,
-): unknown {
-  // props.xxx ?? default
-  const nullishMatch = expr.match(/^props\.(\w+)\s*\?\?\s*(.+)$/)
-  if (nullishMatch) {
-    const propName = nullishMatch[1]
-    const defaultExpr = nullishMatch[2].trim()
-    if (props && propName in props) {
-      return props[propName]
-    }
-    return parseLiteral(defaultExpr)
-  }
-
-  // props.xxx (no default)
-  const propsMatch = expr.match(/^props\.(\w+)$/)
-  if (propsMatch) {
-    if (props && propsMatch[1] in props) {
-      return props[propsMatch[1]]
-    }
-    return null
-  }
-
-  // Literal value
-  return parseLiteral(expr)
-}
-
-function parseLiteral(expr: string): unknown {
-  if (/^-?\d+(\.\d+)?$/.test(expr)) return Number(expr)
-  if (expr === 'true') return true
-  if (expr === 'false') return false
-  if (expr === '[]') return []
-
-  // Non-empty array literal (`[{ id: 'a' }, { id: 'b' }]`, `['x', 'y']`).
-  // Each element is parsed recursively; if any element can't be parsed
-  // (identifier, call, member access, …) the whole array bails to null so
-  // the harness falls back to its `undef` behaviour. Mirrors the object-
-  // literal branch below. Needed so signal initial values that are inline
-  // object/scalar arrays seed the Mojo SSR stash (e.g. the whole-item loop
-  // conditional fixture, whose `items` is `[{ id: 'a' }, …]`).
-  {
-    const t = expr.trim()
-    if (t.startsWith('[') && t.endsWith(']')) {
-      const inner = t.slice(1, -1).trim()
-      if (!inner) return []
-      const out: unknown[] = []
-      for (const seg of splitTopLevelCommas(inner)) {
-        if (!seg.trim()) continue
-        const parsed = parseLiteral(seg.trim())
-        if (parsed === null && seg.trim() !== 'null') return null
-        out.push(parsed)
-      }
-      return out
-    }
-  }
-  // String literal — require matching opener/closer (the previous
-  // regex `^['"]…['"]$` accepted mixed quotes like `'foo"`) and
-  // unescape JS-style escape sequences so `'a\\'b'` round-trips as
-  // `a\'b` instead of leaking the source-level escapes into the
-  // Perl literal (#1413 review).
-  const stringMatch = expr.match(/^(['"])(.*)\1$/s)
-  if (stringMatch) return unescapeJsString(stringMatch[2])
-  // JS object literal (#1407 follow-up): `{ id: 'a', class: 'on' }`.
-  // Used for spread-bag signal initial values in the `jsx-spread-*`
-  // fixture family. Keys may be bare identifiers or string
-  // literals; values are scalars (string / number / boolean /
-  // null) or nested object literals via recursive `parseLiteral`.
-  // Non-empty array values (`[1, 2]`) are NOT supported — only
-  // the `[]` empty-array literal recognised by the early-return
-  // above lowers. Trailing commas (`{ id: 'a', }`) are accepted
-  // by skipping empty segments (#1413 review). Anything the
-  // recursive call can't handle (identifiers, function calls,
-  // member access, non-empty arrays) surfaces as null and bubbles
-  // up so the harness falls back to its existing `undef`
-  // behaviour.
-  const trimmed = expr.trim()
-  if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
-    const inner = trimmed.slice(1, -1).trim()
-    if (!inner) return {}
-    const obj: Record<string, unknown> = {}
-    const pairs = splitTopLevelCommas(inner)
-    for (const pair of pairs) {
-      // Skip empty segments — typically a trailing comma's tail
-      // (#1413 review).
-      if (!pair.trim()) continue
-      const colonIdx = pair.indexOf(':')
-      if (colonIdx < 0) return null
-      let key = pair.slice(0, colonIdx).trim()
-      const val = pair.slice(colonIdx + 1).trim()
-      // Strip key quotes if any — require matching open/close
-      // quote and unescape, same shape as the value-side string
-      // literal handling above (#1413 review).
-      const keyMatch = key.match(/^(['"])(.*)\1$/s)
-      if (keyMatch) key = unescapeJsString(keyMatch[2])
-      const parsedVal = parseLiteral(val)
-      if (parsedVal === null && val !== 'null') return null
-      obj[key] = parsedVal
-    }
-    return obj
-  }
-  return null
-}
-
-/**
- * Split a comma-separated literal body (object-pair list or array element
- * list) on top-level commas only — commas nested inside braces, brackets, or
- * string literals don't split. Backslash-escaped quotes inside strings are
- * honoured (an odd run of backslashes before a quote keeps the string open).
- * Shared by the object- and array-literal branches of {@link parseLiteral}.
- */
-function splitTopLevelCommas(inner: string): string[] {
-  const segments: string[] = []
-  let depth = 0
-  let start = 0
-  let quote: string | null = null
-  for (let i = 0; i < inner.length; i++) {
-    const c = inner[i]
-    if (quote) {
-      if (c === quote) {
-        let backslashes = 0
-        for (let j = i - 1; j >= 0 && inner[j] === '\\'; j--) backslashes++
-        if (backslashes % 2 === 0) quote = null
-      }
-      continue
-    }
-    if (c === '"' || c === "'") {
-      quote = c
-      continue
-    }
-    if (c === '{' || c === '[') depth++
-    else if (c === '}' || c === ']') depth--
-    else if (c === ',' && depth === 0) {
-      segments.push(inner.slice(start, i))
-      start = i + 1
-    }
-  }
-  segments.push(inner.slice(start))
-  return segments
-}
-
-/**
- * Unescape a JS string-literal body (the content between the
- * matching opening and closing quotes, not the quotes themselves).
- * Handles the common single-character escapes `\\`, `\'`, `\"`,
- * `\n`, `\r`, `\t`, `\0`, and the backslash-anything fallback that
- * mirrors JS's "unknown escape is the character itself" semantics.
- * Hex / unicode / octal escapes are intentionally out of scope —
- * the spread-bag fixture corpus uses ASCII identifiers and short
- * literal values, so the harness doesn't need a full JS string
- * decoder (#1413 review).
- */
-function unescapeJsString(s: string): string {
-  return s.replace(/\\(.)/g, (_, c) => {
-    switch (c) {
-      case 'n': return '\n'
-      case 'r': return '\r'
-      case 't': return '\t'
-      case '0': return '\0'
-      // `\\`, `\'`, `\"`, and any other single-character escape
-      // collapse to the literal character (matches JS semantics
-      // for unrecognised escapes).
-      default: return c
-    }
-  })
-}
 
 /**
  * Perl single-quoted string escape: `'` AND `\` need escaping.
@@ -886,34 +728,3 @@ function toPerlLiteral(value: unknown): string {
   return 'undef'
 }
 
-/**
- * Convert a JS literal value to a Perl literal.
- * Handles: numbers, strings, booleans, empty arrays, props.xxx ?? default patterns.
- */
-function jsToPerlValue(jsValue: string): string | null {
-  const v = jsValue.trim()
-
-  // Number
-  if (/^-?\d+(\.\d+)?$/.test(v)) return v
-
-  // String literal
-  if (/^['"].*['"]$/.test(v)) return v
-
-  // Boolean
-  if (v === 'true') return '1'
-  if (v === 'false') return '0'
-
-  // Empty array
-  if (v === '[]') return '[]'
-
-  // props.xxx ?? default — extract the default value
-  const nullishMatch = v.match(/\?\?\s*(.+)$/)
-  if (nullishMatch) {
-    return jsToPerlValue(nullishMatch[1])
-  }
-
-  // props.xxx (no default) — return undef
-  if (v.startsWith('props.')) return 'undef'
-
-  return null
-}

package/src/__tests__/evaluate-signal-init.test.ts

@@ -1,35 +0,0 @@
-import { describe, test, expect } from 'bun:test'
-import { evaluateSignalInit } from '../test-render'
-
-describe('evaluateSignalInit — SSR signal seeding (#1672)', () => {
-  test('parses an inline object-array initial value', () => {
-    // The whole-item loop-conditional fixture seeds `items` from an inline
-    // object array. Without array support this returned null, so `$items` was
-    // undefined in the Mojo SSR render and the loop rendered empty.
-    expect(evaluateSignalInit(`[{ id: 'a' }, { id: 'b' }, { id: 'c' }]`)).toEqual([
-      { id: 'a' },
-      { id: 'b' },
-      { id: 'c' },
-    ])
-  })
-
-  test('parses scalar and mixed arrays, including nested objects', () => {
-    expect(evaluateSignalInit(`['x', 'y']`)).toEqual(['x', 'y'])
-    expect(evaluateSignalInit(`[1, 2, 3]`)).toEqual([1, 2, 3])
-    expect(evaluateSignalInit(`[{ id: 'a', n: 1, ok: true }]`)).toEqual([
-      { id: 'a', n: 1, ok: true },
-    ])
-  })
-
-  test('still parses scalars, empty array, and props passthrough', () => {
-    expect(evaluateSignalInit(`'b'`)).toBe('b')
-    expect(evaluateSignalInit(`5`)).toBe(5)
-    expect(evaluateSignalInit(`[]`)).toEqual([])
-    expect(evaluateSignalInit(`props.value`, { value: 42 })).toBe(42)
-  })
-
-  test('bails to null for arrays with non-literal elements', () => {
-    // A call / identifier element can't be evaluated at seed time.
-    expect(evaluateSignalInit(`[foo(), bar]`)).toBeNull()
-  })
-})