@barefootjs/php 0.18.3 → 0.18.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/php",
-  "version": "0.18.3",
+  "version": "0.18.5",
   "description": "BarefootJS engine-agnostic PHP runtime -- pluggable rendering backend; the shared basis for Twig, Blade and other PHP engine integrations",
   "type": "module",
   "files": [

package/src/BarefootJS.php

@@ -680,6 +680,33 @@ final class BarefootJS
         return (is_nan($n) || is_infinite($n)) ? $n : floor($n + 0.5);
     }
 
+    /** `Math.min(a, b)` / `Math.max(a, b)` -- two-arg forms only (#2168
+     * math-methods). JS returns NaN if either operand is NaN. */
+    public function min($a, $b): float
+    {
+        $x = $this->number($a);
+        $y = $this->number($b);
+        if (is_nan($x)) return $x;
+        if (is_nan($y)) return $y;
+        return $x < $y ? $x : $y;
+    }
+
+    public function max($a, $b): float
+    {
+        $x = $this->number($a);
+        $y = $this->number($b);
+        if (is_nan($x)) return $x;
+        if (is_nan($y)) return $y;
+        return $x > $y ? $x : $y;
+    }
+
+    /** `Math.abs()` (#2168 math-methods). */
+    public function abs($value): float
+    {
+        $n = $this->number($value);
+        return is_nan($n) ? $n : abs($n);
+    }
+
     // -----------------------------------------------------------------
     // Array / String method helpers (#1448 Tier A)
     // -----------------------------------------------------------------
@@ -852,6 +879,46 @@ final class BarefootJS
         return mb_strlen($this->scalarOrEmpty($recv), 'UTF-8');
     }
 
+    /** True for a JS *object* value under the canonical value convention
+     * (`Evaluator::isJsArray`'s docstring): a `stdClass` (the live
+     * representation for a `json_decode()`-sourced object prop) or a
+     * non-list PHP array (a compiler-baked object literal, `toPhpLiteral`'s
+     * `stdClass`-cast form notwithstanding -- defensive, in case a bare
+     * assoc array ever reaches here directly). */
+    private function isJsObject($recv): bool
+    {
+        return $recv instanceof \stdClass || (is_array($recv) && !Evaluator::isJsArray($recv));
+    }
+
+    /**
+     * `Object.entries(x)` (#2168 object-entries-map) -- returns a PHP assoc
+     * array (`key => value`) so the generated Twig/Blade `for`/`@foreach`
+     * unpacks key + value directly via the language's own 2-variable
+     * iteration form. `(array)` on a `stdClass` (or a bare assoc array)
+     * preserves the object's OWN declaration/insertion order -- a PHP
+     * array's iteration order IS its insertion order by language
+     * guarantee, unlike e.g. a Go `map[string]T` or a Perl hash, which
+     * have no such guarantee (see `IRLoop.objectIteration`'s docstring,
+     * `packages/jsx/src/types.ts`, for why those adapters take a
+     * different, sorted-order approach instead).
+     */
+    public function entries($recv): array
+    {
+        return $this->isJsObject($recv) ? (array) $recv : [];
+    }
+
+    /** `Object.keys(x)` -- see `entries()`. */
+    public function keys($recv): array
+    {
+        return $this->isJsObject($recv) ? array_keys((array) $recv) : [];
+    }
+
+    /** `Object.values(x)` -- see `entries()`. */
+    public function values($recv): array
+    {
+        return $this->isJsObject($recv) ? array_values((array) $recv) : [];
+    }
+
     private function arrayIndexOf($recv, $elem, bool $reverse): int
     {
         if (!Evaluator::isJsArray($recv)) {
@@ -914,9 +981,23 @@ final class BarefootJS
         return $out;
     }
 
-    /** `Array.prototype.slice(start, end?)`. */
-    public function slice($recv, $start, $end): array
-    {
+    /** `Array.prototype.slice(start, end?)` AND `String.prototype.slice`
+     * (the `string-slice` divergence) -- the adapter emits the same
+     * `slice(recv, start, end)` call for both receiver shapes (it can't
+     * disambiguate string vs. array at compile time), so this dispatches
+     * on the receiver's PHP type, mirroring `includes` above. String
+     * length/positions use `mb_strlen`/`mb_substr` (UTF-8 code points,
+     * not bytes), matching this runtime's other string helpers. */
+    public function slice($recv, $start, $end)
+    {
+        if (is_string($recv)) {
+            $len = mb_strlen($recv, 'UTF-8');
+            [$s, $e] = $this->clampSliceRange($len, $start, $end);
+            if ($s >= $e) {
+                return '';
+            }
+            return mb_substr($recv, (int) $s, (int) ($e - $s), 'UTF-8');
+        }
         if (!Evaluator::isJsArray($recv)) {
             return [];
         }
@@ -925,6 +1006,16 @@ final class BarefootJS
         if ($len === 0) {
             return [];
         }
+        [$s, $e] = $this->clampSliceRange($len, $start, $end);
+        if ($s >= $e) {
+            return [];
+        }
+        return array_slice($arr, (int) $s, (int) ($e - $s));
+    }
+
+    /** Shared bounds arithmetic for both `slice` branches above. */
+    private function clampSliceRange(int $len, $start, $end): array
+    {
         $s = $start ?? 0;
         if ($s < 0) {
             $s += $len;
@@ -937,10 +1028,7 @@ final class BarefootJS
         }
         $e = max($e, 0);
         $e = min($e, $len);
-        if ($s >= $e) {
-            return [];
-        }
-        return array_slice($arr, (int) $s, (int) ($e - $s));
+        return [$s, $e];
     }
 
     public function reverse($recv): array
@@ -1117,6 +1205,25 @@ final class BarefootJS
         return (string) preg_replace('/^\s+|\s+$/u', '', $this->string($recv));
     }
 
+    /** `String.prototype.trimStart()` / `.trimEnd()` -- the one-sided
+     * siblings of `trim` above (#2183 follow-up), same `\s` /u regex
+     * restricted to one side. */
+    public function trim_start($recv): string
+    {
+        if ($recv === null || is_array($recv) || $recv instanceof \stdClass) {
+            return '';
+        }
+        return (string) preg_replace('/^\s+/u', '', $this->string($recv));
+    }
+
+    public function trim_end($recv): string
+    {
+        if ($recv === null || is_array($recv) || $recv instanceof \stdClass) {
+            return '';
+        }
+        return (string) preg_replace('/\s+$/u', '', $this->string($recv));
+    }
+
     /** `Number.prototype.toFixed(digits)` -- JS rounds the scaled integer
      * half toward +Infinity (the spec's "pick the larger n" tie-break); a
      * bare `sprintf('%.*f')` would round half-to-even, diverging. */
@@ -1208,6 +1315,29 @@ final class BarefootJS
         return substr($s, 0, $i) . $n . substr($s, $i + strlen($o));
     }
 
+    /** `String.prototype.replaceAll(pattern, replacement)` -- string-pattern
+     * form only (#2182), replacing EVERY occurrence (the all-occurrences
+     * sibling of `replace` above). A non-empty pattern uses PHP's own
+     * `str_replace`, which is global-by-default and treats both the pattern
+     * and the replacement literally (no backreference interpolation) --
+     * matching JS. PHP's `str_replace("", ...)` is a no-op, unlike JS,
+     * which inserts the replacement at every boundary (including before
+     * the first and after the last character,
+     * `"abc".replaceAll("", "X")` -> "XaXbXcX") -- so the empty pattern is
+     * special-cased with `mb_str_split` (UTF-8 code points, matching this
+     * runtime's other string helpers). */
+    public function replace_all($recv, $pattern, $replacement): string
+    {
+        $s = $this->scalarOrEmpty($recv);
+        $o = $this->string($pattern);
+        $n = $this->string($replacement);
+        if ($o === '') {
+            $chars = $s === '' ? [] : mb_str_split($s, 1, 'UTF-8');
+            return implode($n, array_merge([''], $chars, ['']));
+        }
+        return str_replace($o, $n, $s);
+    }
+
     /** `queryHref(base, {...})` (#2042) -- build `"$base?k=v&..."` from a
      * flat (guard, key, value) triple sequence. A pair is included iff its
      * guard is JS-truthy AND its value is a non-empty string; an array value

package/tests/test_helper_vectors.php

@@ -146,13 +146,19 @@ function bfv_call(BarefootJS $bf, string $fn, array $args)
         case 'floor': return $bf->floor($args[0]);
         case 'ceil': return $bf->ceil($args[0]);
         case 'round': return $bf->round($args[0]);
+        case 'min': return $bf->min($args[0], $args[1]);
+        case 'max': return $bf->max($args[0], $args[1]);
+        case 'abs': return $bf->abs($args[0]);
         case 'to_fixed': return $bf->to_fixed(...$args);
         case 'lower': return $bf->lc($args[0]);
         case 'upper': return $bf->uc($args[0]);
         case 'trim': return $bf->trim($args[0]);
+        case 'trim_start': return $bf->trim_start($args[0]);
+        case 'trim_end': return $bf->trim_end($args[0]);
         case 'starts_with': return $bf->starts_with(...$args);
         case 'ends_with': return $bf->ends_with(...$args);
         case 'replace': return $bf->replace(...$args);
+        case 'replace_all': return $bf->replace_all(...$args);
         case 'repeat': return $bf->repeat(...$args);
         case 'pad_start': return $bf->pad_start(...$args);
         case 'pad_end': return $bf->pad_end(...$args);

package/tests/test_template_primitives.php

@@ -188,6 +188,19 @@ bf_test('slice mutation isolation and clamping', function () use ($bf) {
     bf_assert_eq($src, ['a', 'b', 'c']);
 });
 
+bf_test('slice string receiver', function () use ($bf) {
+    // The `string-slice` divergence (#2182): a string receiver used to
+    // fall through the array-only branch and return an empty array
+    // instead of a substring.
+    $word = 'barefootjs';
+    bf_assert_eq($bf->slice($word, 0, 4), 'bare');
+    bf_assert_eq($bf->slice($word, -4, null), 'otjs');
+    bf_assert_eq($bf->slice($word, 4, null), 'footjs');
+    bf_assert_eq($bf->slice($word, 5, 2), '');
+    // Multi-byte: index by character, not byte.
+    bf_assert_eq($bf->slice('héllo', 0, 2), 'hé');
+});
+
 bf_test('reverse mutation isolation', function () use ($bf) {
     bf_assert_eq($bf->reverse(['a', 'b', 'c']), ['c', 'b', 'a']);
     bf_assert_eq($bf->reverse([]), []);
@@ -211,6 +224,33 @@ bf_test('trim', function () use ($bf) {
     bf_assert_eq($bf->trim(42), '42');
 });
 
+// `trim_start` / `trim_end` -- the one-sided siblings of `trim` above
+// (#2183 follow-up). Padding BOTH sides of the flagship input so a
+// swapped side (or a routed-through-both-sides regression) fails visibly.
+bf_test('trim_start / trim_end', function () use ($bf) {
+    bf_assert_eq($bf->trim_start('   padded   '), 'padded   ');
+    bf_assert_eq($bf->trim_end('   padded   '), '   padded');
+
+    bf_assert_eq($bf->trim_start("\t\nleading"), 'leading');
+    bf_assert_eq($bf->trim_end('trailing  '), 'trailing');
+
+    bf_assert_eq($bf->trim_start('no-pad'), 'no-pad');
+    bf_assert_eq($bf->trim_end('no-pad'), 'no-pad');
+
+    bf_assert_eq($bf->trim_start('   '), '');
+    bf_assert_eq($bf->trim_end('   '), '');
+
+    bf_assert_eq($bf->trim_start(''), '');
+    bf_assert_eq($bf->trim_end(''), '');
+
+    bf_assert_eq($bf->trim_start(null), '');
+    bf_assert_eq($bf->trim_end(null), '');
+    bf_assert_eq($bf->trim_start(['a' => 1]), '');
+    bf_assert_eq($bf->trim_end(['a' => 1]), '');
+    bf_assert_eq($bf->trim_start(42), '42');
+    bf_assert_eq($bf->trim_end(42), '42');
+});
+
 bf_test('split', function () use ($bf) {
     bf_assert_eq($bf->split('a,b,c', ','), ['a', 'b', 'c']);
     bf_assert_eq($bf->split('a.b.c', '.'), ['a', 'b', 'c']);