@barefootjs/mojolicious 0.5.3 → 0.6.1

package/src/adapter/mojo-adapter.ts

@@ -56,7 +56,7 @@ import { isAriaBooleanAttr, isBooleanResultExpr } from './boolean-result'
  * the `IRNodeEmitter` interface.
  */
 type MojoRenderCtx = Record<string, never>
-import type { ParsedExpr, ParsedStatement, SortComparator, TemplatePart } from '@barefootjs/jsx'
+import type { ParsedExpr, ParsedStatement, SortComparator, ReduceOp, FlatDepth, FlatMapOp, TemplatePart } from '@barefootjs/jsx'
 import { BF_SLOT, BF_COND } from '@barefootjs/shared'
 
 interface PrimitiveSpec {
@@ -1295,9 +1295,10 @@ function renderArrayMethod(
       // arr.join(sep) → join(sep, @{arr}). The default `${obj}->{join}`
       // hash-lookup fallback would emit invalid Perl, which is why the
       // IR carves out a dedicated method node instead of routing
-      // through the generic call dispatcher.
+      // through the generic call dispatcher. `.join()` defaults the
+      // separator to `,` (JS) and ignores any extra argument.
       const obj = emit(object)
-      const sep = emit(args[0])
+      const sep = args.length >= 1 ? emit(args[0]) : `','`
       return `join(${sep}, @{${obj}})`
     }
     case 'includes': {
@@ -1333,9 +1334,10 @@ function renderArrayMethod(
       // `.at(i)` with negative-index support — `.at(-1)` is the
       // last element. The Mojo helper wraps the same `length + i`
       // arithmetic the Go `bf_at` does so the lowering stays
-      // symmetric across adapters.
+      // symmetric across adapters. `.at()` with no argument is `.at(0)`
+      // (the first element); extra arguments are ignored.
       const obj = emit(object)
-      const idx = emit(args[0])
+      const idx = args.length >= 1 ? emit(args[0]) : '0'
       return `bf->at(${obj}, ${idx})`
     }
     case 'concat': {
@@ -1343,20 +1345,26 @@ function renderArrayMethod(
       // ref so the result composes with `.join(...)` / other
       // array-shape methods downstream (the canonical Tier A
       // conformance fixture chains `.concat(...).join(' ')`).
+      // `.concat()` with no argument is a shallow copy — indistinguishable
+      // from the receiver in an SSR snapshot, so it lowers to the receiver.
+      if (args.length === 0) {
+        return emit(object)
+      }
       const a = emit(object)
       const b = emit(args[0])
       return `bf->concat(${a}, ${b})`
     }
     case 'slice': {
-      // `.slice(start)` / `.slice(start, end)`. The Mojo helper
-      // mirrors the Go arithmetic (negative-index normalisation,
-      // out-of-bounds clamping, empty result on start >= end).
-      // Absent `end` lowers as `undef`, which the helper treats as
-      // "to length". Returns a new ARRAY ref so the result composes
-      // with `.join(...)` downstream.
+      // `.slice()` / `.slice(start)` / `.slice(start, end)`. The Mojo
+      // helper mirrors the Go arithmetic (negative-index normalisation,
+      // out-of-bounds clamping, empty result on start >= end). A
+      // missing `start` defaults to 0 (full copy); an absent `end`
+      // lowers as `undef`, which the helper treats as "to length". JS
+      // ignores a third+ argument. Returns a new ARRAY ref so the
+      // result composes with `.join(...)` downstream.
       const recv = emit(object)
-      const start = emit(args[0])
-      const end = args.length === 2 ? emit(args[1]) : 'undef'
+      const start = args.length >= 1 ? emit(args[0]) : '0'
+      const end = args.length >= 2 ? emit(args[1]) : 'undef'
       return `bf->slice(${recv}, ${start}, ${end})`
     }
     case 'reverse':
@@ -1388,6 +1396,86 @@ function renderArrayMethod(
       const recv = emit(object)
       return `bf->trim(${recv})`
     }
+    case 'split': {
+      // `.split()` / `.split(sep)` / `.split(sep, limit)` — string →
+      // ARRAY ref via `bf->split`. With no separator the helper returns
+      // the whole string as a single element; otherwise it quotemetas
+      // the separator (literal match, not regex) and keeps trailing
+      // empties (`-1`), staying byte-equal with Go's `bf_split`. The
+      // optional `limit` caps the pieces; JS ignores a third+ argument.
+      // See #1448 Tier B.
+      const recv = emit(object)
+      if (args.length === 0) {
+        return `bf->split(${recv})`
+      }
+      const sep = emit(args[0])
+      if (args.length === 1) {
+        return `bf->split(${recv}, ${sep})`
+      }
+      const limit = emit(args[1])
+      return `bf->split(${recv}, ${sep}, ${limit})`
+    }
+    case 'startsWith':
+    case 'endsWith': {
+      // `.startsWith(prefix, position?)` / `.endsWith(suffix,
+      // endPosition?)` — string → boolean. The Perl helpers
+      // (`bf->starts_with` / `bf->ends_with`) do a `substr`-anchored
+      // comparison so the search string is matched literally (no regex
+      // metachar surprises) and undef receivers stay quiet. The optional
+      // second argument re-anchors the test; JS ignores a third+
+      // argument. See #1448 Tier B.
+      const fn = method === 'startsWith' ? 'starts_with' : 'ends_with'
+      const recv = emit(object)
+      const arg = emit(args[0])
+      if (args.length >= 2) {
+        return `bf->${fn}(${recv}, ${arg}, ${emit(args[1])})`
+      }
+      return `bf->${fn}(${recv}, ${arg})`
+    }
+    case 'replace': {
+      // `.replace(old, new)` — string-pattern form, first occurrence.
+      // The `bf->replace` helper splices via index/substr (not `s///`)
+      // so both the pattern and the replacement are literal — no Perl
+      // regex metacharacters and no `$1` / `$&` interpolation in the
+      // replacement, keeping it byte-equal with Go's `bf_replace`. The
+      // regex-pattern form is refused upstream at the parser. See
+      // #1448 Tier B.
+      const recv = emit(object)
+      const oldS = emit(args[0])
+      const newS = emit(args[1])
+      return `bf->replace(${recv}, ${oldS}, ${newS})`
+    }
+    case 'repeat': {
+      // `.repeat(n)` — string repeated `n` times. The `bf->repeat`
+      // helper wraps Perl's `x` operator with the same negative-count
+      // → "" clamp and integer truncation Go's `bf_repeat` applies, so
+      // the two adapters stay byte-equal. Full JS arity: the no-argument
+      // form is `repeat(0)` → ""; a second+ argument is ignored.
+      // See #1448 Tier B.
+      const recv = emit(object)
+      const count = args.length === 0 ? '0' : emit(args[0])
+      return `bf->repeat(${recv}, ${count})`
+    }
+    case 'padStart':
+    case 'padEnd': {
+      // `.padStart(target, pad?)` / `.padEnd(target, pad?)`. The
+      // `bf->pad_*` helpers default the pad to a single space when the
+      // arg is omitted and measure length in characters, matching Go's
+      // rune-based `bf_pad_*`. Full JS arity: the no-argument form is
+      // `padStart(0)` → the receiver unchanged; a third+ argument is
+      // ignored. See #1448 Tier B.
+      const fn = method === 'padStart' ? 'pad_start' : 'pad_end'
+      const recv = emit(object)
+      if (args.length === 0) {
+        return `bf->${fn}(${recv}, 0)`
+      }
+      const target = emit(args[0])
+      if (args.length === 1) {
+        return `bf->${fn}(${recv}, ${target})`
+      }
+      const pad = emit(args[1])
+      return `bf->${fn}(${recv}, ${target}, ${pad})`
+    }
     default: {
       // TS-level exhaustiveness guard. If this throws at runtime, the
       // IR was constructed against a newer `ArrayMethod` variant that
@@ -1445,6 +1533,64 @@ function renderSortMethod(recv: string, c: SortComparator): string {
   return `bf->sort(${recv}, { keys => [${keyHashes.join(', ')}] })`
 }
 
+/**
+ * Render a `.reduce(fn, init)` arithmetic fold (#1448 Tier C) as a
+ * `bf->reduce(...)` call. The structured `ReduceOp` maps to the Perl
+ * helper's options hash:
+ *
+ *   bf->reduce($recv, { op => '+', key_kind => 'field', key => 'duration',
+ *                       type => 'numeric', init => 0 })
+ *
+ * A numeric init passes through as a bare Perl number (`0`, `-1`); a
+ * string init (concat fold) is re-quoted from its literal contents.
+ */
+function renderReduceMethod(recv: string, op: ReduceOp, direction: 'left' | 'right'): string {
+  const keyEntry =
+    op.key.kind === 'self'
+      ? `key_kind => 'self'`
+      : `key_kind => 'field', key => '${op.key.field}'`
+  // `op.init` is the decoded seed value. A numeric seed is already a
+  // canonical decimal literal Perl reads directly; a concat seed is the
+  // string contents, embedded in a single-quoted Perl literal. The `'`
+  // escape is REQUIRED: a seed decoded from a double-quoted JS literal
+  // (e.g. `"a'b"`) is escape-free yet contains an apostrophe. A literal
+  // backslash can't occur (it would need a `\\` escape, which the parser
+  // refuses), but escaping it too keeps this self-contained.
+  const init =
+    op.type === 'string'
+      ? `'${op.init.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`
+      : op.init
+  // `direction` is "left" (reduce) or "right" (reduceRight); the Perl
+  // helper reverses the list for "right". Only observable for concat.
+  return `bf->reduce(${recv}, { op => '${op.op}', ${keyEntry}, type => '${op.type}', init => ${init}, direction => '${direction}' })`
+}
+
+// `.flat(depth?)` → `bf->flat($recv, $depth)`. The `Infinity` form lowers
+// to the `-1` sentinel (flatten fully); a finite depth flattens that many
+// levels (`0` = shallow copy). See `sub flat` in BarefootJS.pm. (#1448)
+function renderFlatMethod(recv: string, depth: FlatDepth): string {
+  const d = depth === 'infinity' ? -1 : depth
+  return `bf->flat(${recv}, ${d})`
+}
+
+// `.flatMap(i => i)` / `.flatMap(i => i.field)` → `bf->flat_map($recv,
+// 'self'|'field', 'field')`, and the array-literal tuple form
+// `i => [i.a, i.b]` → `bf->flat_map_tuple($recv, ['field','a'], ...)`
+// (one arrayref per leaf). The field key is the raw JS prop name (Perl
+// hashes are keyed by it), mirroring `bf->reduce`. See `sub flat_map` /
+// `sub flat_map_tuple` in BarefootJS.pm.
+function renderFlatMapMethod(recv: string, op: FlatMapOp): string {
+  const proj = op.projection
+  if (proj.kind === 'tuple') {
+    const specs = proj.elements
+      .map(l => (l.kind === 'self' ? `['self', '']` : `['field', '${l.field}']`))
+      .join(', ')
+    return `bf->flat_map_tuple(${recv}, ${specs})`
+  }
+  if (proj.kind === 'self') return `bf->flat_map(${recv}, 'self', '')`
+  return `bf->flat_map(${recv}, 'field', '${proj.field}')`
+}
+
 /** True when `type` is the `string` primitive. */
 function isStringTypeInfo(type: TypeInfo | undefined): boolean {
   return type?.kind === 'primitive' && type.primitive === 'string'
@@ -1627,6 +1773,18 @@ class MojoFilterEmitter implements ParsedExprEmitter {
     return renderSortMethod(emit(object), comparator)
   }
 
+  reduceMethod(method: 'reduce' | 'reduceRight', object: ParsedExpr, reduceOp: ReduceOp, emit: (e: ParsedExpr) => string): string {
+    return renderReduceMethod(emit(object), reduceOp, method === 'reduceRight' ? 'right' : 'left')
+  }
+
+  flatMethod(object: ParsedExpr, depth: FlatDepth, emit: (e: ParsedExpr) => string): string {
+    return renderFlatMethod(emit(object), depth)
+  }
+
+  flatMapMethod(object: ParsedExpr, op: FlatMapOp, emit: (e: ParsedExpr) => string): string {
+    return renderFlatMapMethod(emit(object), op)
+  }
+
   conditional(_test: ParsedExpr, _consequent: ParsedExpr, _alternate: ParsedExpr): string {
     return '1'
   }
@@ -1808,6 +1966,18 @@ class MojoTopLevelEmitter implements ParsedExprEmitter {
     return renderSortMethod(emit(object), comparator)
   }
 
+  reduceMethod(method: 'reduce' | 'reduceRight', object: ParsedExpr, reduceOp: ReduceOp, emit: (e: ParsedExpr) => string): string {
+    return renderReduceMethod(emit(object), reduceOp, method === 'reduceRight' ? 'right' : 'left')
+  }
+
+  flatMethod(object: ParsedExpr, depth: FlatDepth, emit: (e: ParsedExpr) => string): string {
+    return renderFlatMethod(emit(object), depth)
+  }
+
+  flatMapMethod(object: ParsedExpr, op: FlatMapOp, emit: (e: ParsedExpr) => string): string {
+    return renderFlatMapMethod(emit(object), op)
+  }
+
   conditional(
     test: ParsedExpr,
     consequent: ParsedExpr,