@barefootjs/jsx 0.18.4 → 0.18.7

package/src/signal-init-eval.ts

@@ -0,0 +1,165 @@
+/**
+ * TEST-HARNESS ONLY. Evaluate a signal initializer / prop-default source
+ * expression against a mock `props` object by EXECUTING it (`new
+ * Function`, with `undefined` shadowing the globals listed below), the
+ * same way the Hono/CSR conformance reference produces its value — by
+ * actually running the component. Never call this from a build path (`bf
+ * build`, `compileJSX`, any adapter's `generate`); it exists only so each
+ * adapter's `test-render.ts` conformance harness can seed a signal/
+ * prop-default for a non-JS-runtime SSR render (PHP/Ruby/Python/Perl/Go)
+ * that matches what Hono would compute. (#2209)
+ *
+ * NOT a security sandbox — the global shadowing below is a determinism
+ * tripwire (catches the common accidental-nondeterminism case, e.g.
+ * `Date.now()`), not containment: a sufficiently creative expression can
+ * still reach the real global scope (`new Function` bodies execute
+ * unlexically-scoped, so e.g. `[].constructor.constructor('return
+ * Date')()` recovers `Date` even though the bare name is shadowed, and
+ * `eval` can't be shadowed at all — JS forbids declaring or binding a
+ * parameter literally named `eval` in strict-mode code). Do not widen this
+ * module's use to anything but first-party fixture source. The actual
+ * trust boundary is that the evaluated text is first-party fixture
+ * source, already compiled by this same process — the conformance harness
+ * already executes fixture-derived code far more invasively (spawning
+ * `ruby`/`php`/`perl`/`go run` on generated programs). This module is
+ * never reachable from anything a real end user's untrusted input could
+ * influence.
+ *
+ * Why real execution instead of a hand-rolled evaluator: the initializer
+ * source is an arbitrary JS-subset expression over `props` (e.g. `(props.x
+ * ?? []).map(t => ({ ...t, editing: false }))`, #2209's actual repro) —
+ * every previous approach here was a regex/pattern-match over a small
+ * catalogue of recognized shapes (`props.x`, `props.x ?? default`, a bare
+ * literal), and #2209 is literally "the catalogue missed a shape" (the
+ * THIRD such miss on this codebase, per the superseded
+ * `evaluate-signal-init.test.ts`'s own #1672 pins). A hand-written
+ * evaluator over `ParsedExpr` would face the same drift, and can't
+ * represent object spread (`{ ...t, editing: false }`) without extending
+ * `ParsedExpr` — a production-compiler change that ripples into every
+ * adapter's exhaustive switch, disproportionate for a test-only need.
+ * `new Function` delegates parsing to the JS engine itself — CLAUDE.md's
+ * regex-parsing ban exists precisely to avoid the false-match/missed-shape
+ * failure mode this replaces.
+ *
+ * Shadowed as `undefined` (best-effort determinism, not containment — see
+ * above): `globalThis`, `window`, `document`, `Date`, `Math`, `crypto`,
+ * `performance`, `fetch`, `setTimeout`, `setInterval`, `require`,
+ * `process`, `Function`. (`eval` is deliberately absent from this list —
+ * it cannot be shadowed as a parameter name in strict-mode code; see
+ * above.)
+ *
+ * `props` bare-identifier destructured params (`createSignal(count)` where
+ * `count` is a destructured prop, not a `props.x` member) are NOT bound —
+ * the evaluator only exposes `props` — so such an initializer throws
+ * `ReferenceError` and falls back to "unset", matching every prior
+ * evaluator's behavior for that shape. Extending the environment with
+ * `ir.metadata.propsParams` bindings is a natural follow-up if a fixture
+ * ever needs it.
+ */
+
+const BLOCKED_GLOBALS = [
+  'globalThis',
+  'window',
+  'document',
+  'Date',
+  'Math',
+  'crypto',
+  'performance',
+  'fetch',
+  'setTimeout',
+  'setInterval',
+  'require',
+  'process',
+  'Function',
+] as const
+
+export type SignalInitEvalResult = { ok: true; value: unknown } | { ok: false }
+
+/**
+ * A value the harness's downstream language serializers (JSON/Python/PHP/
+ * Perl/Ruby literal builders) can actually marshal: `null`, a boolean, a
+ * number (including non-finite — several serializers already special-case
+ * NaN/Infinity), a string, a dense array with no holes and no `undefined`
+ * elements, or a plain object (`Object.prototype` or null prototype only —
+ * rejects class instances, functions, Maps/Sets, etc). Rejects genuine
+ * cycles; a shared (non-cyclic) reference appearing more than once — e.g.
+ * the same object at two array indices — is fine (JSON-equivalent
+ * behavior just duplicates it), so `ancestors` tracks only the current
+ * recursion path, not every value ever visited.
+ */
+function isTransportable(value: unknown, ancestors: Set<unknown> = new Set()): boolean {
+  if (value === null) return true
+  const t = typeof value
+  if (t === 'boolean' || t === 'number' || t === 'string') return true
+  if (t !== 'object') return false
+  if (ancestors.has(value)) return false // a real cycle (value is its own ancestor)
+  ancestors.add(value)
+  try {
+    if (Array.isArray(value)) {
+      // `Array.prototype.every` silently skips holes (`[1, , 3]`), so a
+      // sparse array would otherwise pass — compare against the own
+      // enumerable key count (holes aren't own keys) to catch that.
+      if (Object.keys(value).length !== value.length) return false
+      return value.every(el => el !== undefined && isTransportable(el, ancestors))
+    }
+    const proto = Object.getPrototypeOf(value)
+    if (proto !== Object.prototype && proto !== null) return false
+    return Object.values(value as Record<string, unknown>).every(v => isTransportable(v, ancestors))
+  } finally {
+    ancestors.delete(value)
+  }
+}
+
+/**
+ * Evaluate `expr` (a JS-subset source expression) against `props`. Returns
+ * `{ ok: false }` when the expression fails to parse, throws at evaluation
+ * time (e.g. a `ReferenceError` for an unbound identifier), or evaluates to
+ * something the downstream serializers can't marshal (see
+ * {@link isTransportable}).
+ */
+export function tryEvaluateSignalInit(
+  expr: string,
+  props?: Record<string, unknown>,
+): SignalInitEvalResult {
+  const src = expr.trim()
+  if (src === '') return { ok: false }
+  let fn: (props: Record<string, unknown>, ...blocked: undefined[]) => unknown
+  try {
+    // `props` plus the blocked-globals shadows are the only bindings
+    // passed in — best-effort determinism, not containment; see the file
+    // docstring for the trust-boundary rationale (test-harness-only,
+    // never a build path).
+    fn = new Function(
+      'props',
+      ...BLOCKED_GLOBALS,
+      `'use strict'; return (\n${src}\n);`,
+    ) as typeof fn
+  } catch {
+    return { ok: false }
+  }
+  try {
+    const value = fn(props ?? {})
+    // `undefined` at the TOP level is a genuine, distinguishable result
+    // (e.g. an explicit `undefined` initializer, or `props.x` with no `x`
+    // and no `??` fallback) — not a marshal failure. `evaluateSignalInit`'s
+    // wrapper still collapses it to the "skip" outcome; callers that need
+    // the distinction use this function directly.
+    if (value === undefined) return { ok: true, value: undefined }
+    return isTransportable(value) ? { ok: true, value } : { ok: false }
+  } catch {
+    return { ok: false }
+  }
+}
+
+/**
+ * Drop-in replacement for the harnesses' former per-adapter regex
+ * evaluator: `null` means "could not evaluate, or evaluated to
+ * `undefined` — leave the signal/default unseeded", matching every prior
+ * evaluator's convention (an explicit JS `null` initializer also maps to
+ * `null` — the same "skip" outcome, since none of these harnesses
+ * distinguish "explicitly null" from "unset" downstream).
+ */
+export function evaluateSignalInit(expr: string, props?: Record<string, unknown>): unknown {
+  const result = tryEvaluateSignalInit(expr, props)
+  return result.ok && result.value !== undefined ? result.value : null
+}

package/src/static-literal.ts

@@ -0,0 +1,128 @@
+/**
+ * Fully compile-time-known literal evaluation (#2208). A `ParsedExpr` that
+ * is a literal, a no-substitution (or fully-static) template literal, an
+ * array-literal of pure elements, or an object-literal of pure values
+ * evaluates here to its plain JS value. Consumed by each adapter's
+ * `renderLoop` to admit a function-scope local const whose initializer is
+ * entirely known at compile time as a loop source — inlining its value the
+ * same way a module-scope const already is — while still refusing a
+ * runtime-computed expression (`Object.entries(props.tags).filter(...)`,
+ * #2069) with BF101, since `call`/unresolvable-`member` shapes fall through
+ * to `null` below.
+ *
+ * Analysis only: this module never emits template syntax. Each adapter
+ * serializes the resolved JS value into its own native literal syntax
+ * (`packages/adapter-<name>/src/adapter/lib/static-value.ts`).
+ */
+
+import type { ParsedExpr } from './expression-parser.ts'
+import type { ConstantInfo } from './types.ts'
+
+/**
+ * Recursively evaluate a `ParsedExpr` that is a fully compile-time-known
+ * literal to its JS value. `bindings` lets a caller resolve identifiers
+ * (and member reads off them) against already-evaluated values — e.g. the
+ * Go adapter binding a loop's item parameter to one already-resolved array
+ * element while baking per-item child-component props. Returns `null` when
+ * the expression is not statically known (depends on a prop, signal,
+ * function call, or an identifier absent from `bindings`).
+ */
+export function evaluateStaticLiteral(
+  expr: ParsedExpr,
+  bindings?: ReadonlyMap<string, unknown>,
+): { value: unknown } | null {
+  switch (expr.kind) {
+    case 'literal':
+      return { value: expr.value }
+    case 'template-literal': {
+      let out = ''
+      for (const part of expr.parts) {
+        if (part.type === 'string') {
+          out += part.value
+          continue
+        }
+        const resolved = evaluateStaticLiteral(part.expr, bindings)
+        if (!resolved) return null
+        out += String(resolved.value)
+      }
+      return { value: out }
+    }
+    case 'array-literal': {
+      const values: unknown[] = []
+      for (const element of expr.elements) {
+        const resolved = evaluateStaticLiteral(element, bindings)
+        if (!resolved) return null
+        values.push(resolved.value)
+      }
+      return { value: values }
+    }
+    case 'object-literal': {
+      // Shorthand (`{ a }`) and explicit (`{ a: value }`) properties both
+      // carry their resolved tree in `value` (shorthand's is an
+      // `identifier`) — recursing here handles both uniformly: a shorthand
+      // property only resolves when `bindings` supplies it.
+      const out: Record<string, unknown> = {}
+      for (const prop of expr.properties) {
+        const resolved = evaluateStaticLiteral(prop.value, bindings)
+        if (!resolved) return null
+        out[prop.key] = resolved.value
+      }
+      return { value: out }
+    }
+    case 'unary': {
+      const resolved = evaluateStaticLiteral(expr.argument, bindings)
+      if (!resolved) return null
+      if (expr.op === '-') return typeof resolved.value === 'number' ? { value: -resolved.value } : null
+      if (expr.op === '+') return typeof resolved.value === 'number' ? { value: +resolved.value } : null
+      if (expr.op === '!') return { value: !resolved.value }
+      return null
+    }
+    case 'identifier':
+      return bindings?.has(expr.name) ? { value: bindings.get(expr.name) } : null
+    case 'member': {
+      const base = evaluateStaticLiteral(expr.object, bindings)
+      if (!base || base.value === null || typeof base.value !== 'object') return null
+      return { value: (base.value as Record<string, unknown>)[expr.property] }
+    }
+    case 'index-access': {
+      const base = evaluateStaticLiteral(expr.object, bindings)
+      const index = evaluateStaticLiteral(expr.index, bindings)
+      if (!base || !index || !Array.isArray(base.value) || typeof index.value !== 'number') return null
+      return { value: base.value[index.value] }
+    }
+    default:
+      return null
+  }
+}
+
+/** `true` iff {@link evaluateStaticLiteral} resolves `expr` with no bindings. */
+export function isFullyStaticLiteral(expr: ParsedExpr): boolean {
+  return evaluateStaticLiteral(expr) !== null
+}
+
+/**
+ * Shared loop-source resolution for `renderLoop` across adapters: the loop
+ * array is either an inline array-literal, or a bare identifier naming a
+ * FUNCTION-scope (`!isModule`) local const whose initializer evaluates
+ * statically. Module-scope consts are deliberately excluded — an existing,
+ * separate seeding path already handles those. Returns the evaluated items,
+ * or `null` if the source isn't resolvable this way (including when it
+ * resolves to something other than an array).
+ */
+export function resolveStaticLoopSource(
+  arrayParsed: ParsedExpr | undefined,
+  localConstants: ReadonlyArray<ConstantInfo> | undefined,
+  opts?: { isNameShadowed?: (name: string) => boolean },
+): unknown[] | null {
+  if (!arrayParsed) return null
+  let target = arrayParsed
+  if (arrayParsed.kind === 'identifier') {
+    if (opts?.isNameShadowed?.(arrayParsed.name)) return null
+    const local = localConstants?.find(c => c.name === arrayParsed.name)
+    if (!local || local.isModule || !local.parsed) return null
+    target = local.parsed
+  }
+  const resolved = evaluateStaticLiteral(target)
+  if (!resolved || !Array.isArray(resolved.value)) return null
+  return resolved.value
+}

package/src/types.ts

@@ -574,6 +574,74 @@ export interface IRLoop {
    */
   iterationShape?: 'entries' | 'keys'
 
+  /**
+   * Pre-`.map()` object iteration (#2168 object-entries-map). Distinct
+   * from {@link iterationShape}, which is scoped ENTIRELY to an array's
+   * own zero-arg `.entries()`/`.keys()`/`.values()` methods — those
+   * synthesize a real numeric index off the array's position, and every
+   * adapter's consumption of `iterationShape` assumes an actual
+   * array/slice underneath.
+   *
+   * `objectIteration` instead records the STATIC `Object.entries(x)` /
+   * `Object.keys(x)` / `Object.values(x)` call form, where `x` is a
+   * plain object/Record (not an array): the "index" bound for `'entries'`
+   * is a STRING KEY, not a numeric position, and the collection an
+   * adapter must iterate is its native map/dict/hash type, not an
+   * array/slice. `transformMapCall` strips the `Object.<method>(...)`
+   * wrapper the same way it strips `arr.entries()` — `array`/`arrayParsed`
+   * end up holding just `x` — and records the shape here so each
+   * adapter's loop renderer picks the right native construct:
+   *
+   *   - `'entries'` → both `index` (bound to the KEY) and `param` (bound
+   *     to the VALUE), synthesized from the 2-element destructure the
+   *     same way `iterationShape: 'entries'` is (see `jsx-to-ir.ts`'s
+   *     `transformMapCall`) — e.g. Jinja `for k, v in x.items()`.
+   *   - `'keys'` → `param` bound to the key only — e.g. Jinja
+   *     `for k in x.keys()`.
+   *   - `'values'` → `param` bound to the value only — e.g. Jinja
+   *     `for v in x.values()`. Unlike the array case, `'values'` is NOT
+   *     a no-op here: `Object.values(x)` genuinely differs from
+   *     iterating `x` itself (`x` isn't iterable at all as a plain
+   *     object), so it must be recorded.
+   *
+   * Iteration ORDER is native-map-dependent: Python `dict`/PHP
+   * array-object/Ruby `Hash` preserve the source object's insertion
+   * order (matching JS `Object.entries()` semantics exactly), so Jinja,
+   * Twig, Blade, and ERB lower directly to their native map/dict/hash
+   * iteration. Go's `map[string]T`, Rust's `BTreeMap` (deliberate design,
+   * see `num.rs`), and Perl's hash (Xslate/Mojolicious) have NO
+   * order-preserving native map type, so those four instead lower to a
+   * DETERMINISTIC SORTED-BY-KEY iteration — Go's `{{range}}` (the
+   * stdlib's own `fmtsort`), minijinja's `BTreeMap` (already sorted),
+   * Kolon's `.kv()`/`.keys()`/`.values()` (verified empirically sorted),
+   * and Mojolicious's explicit `sort keys %$hash` (mirroring the
+   * existing `spread_attrs`/`_style_to_css` convention in
+   * `BarefootJS.pm`). This is a documented, permanent known limitation
+   * relative to JS's insertion-order guarantee (not a follow-up TODO) —
+   * true insertion order is physically unrecoverable from those
+   * languages' native map types once constructed, so sorted order is the
+   * best available deterministic approximation, not an interim refusal.
+   *
+   * Only the OUTERMOST, unchained `Object.<method>(x).map(cb)` shape is
+   * recognized — mirroring `iterationShape`'s own scope, chaining
+   * (`Object.entries(x).filter(pred).map(cb)`) is not (yet) recognized
+   * either, same as the array case.
+   */
+  objectIteration?: 'entries' | 'keys' | 'values'
+
+  /**
+   * Count of enclosing `.map()` loops (0 = outermost, 1 = nested one
+   * level deep, ...). Adapters use this to derive the loop body's
+   * `key`/`data-key` attribute suffix — `depth > 0 ? 'data-key-' +
+   * depth : 'data-key'` — matching `keyAttrName()` in
+   * `ir-to-client-js/utils.ts`, which the CSR path and the Hono SSR
+   * adapter each already derive independently (a recursion counter and
+   * a push/pop stack respectively). Before this field, the 8 template
+   * (non-JS) adapters had no depth awareness at all and always emitted
+   * plain `data-key` on nested-loop items (#2168 nested-loop-outer-binding).
+   */
+  depth: number
+
   /**
    * When true, loop should be evaluated on client side only.
    * SSR adapters should skip rendering and output placeholder markers.