@barefootjs/blade 0.1.0

package/README.md

@@ -0,0 +1,73 @@
+# @barefootjs/blade
+
+Laravel Blade (PHP) adapter for BarefootJS: compiles the BarefootJS IR
+(JSX → IR, see `spec/compiler.md`) into `.blade.php` template files plus the
+client JS bundle every other adapter produces, and ships a PHP rendering
+runtime (`php/src/`) that renders those templates through `illuminate/view`
+used standalone — no Laravel application/container is required.
+
+Near-mechanical port of `@barefootjs/twig` (the Twig adapter) to Blade
+syntax. See `src/adapter/blade-adapter.ts`'s header comment for the full
+Twig↔Blade syntax-mapping table and the JS/PHP semantics divergences this
+port handles uniformly (truthiness, stringification, reserved-word
+identifier mangling, `$bf->eq`/`$bf->neq` for JS strict equality, `data_get`
+for polymorphic member/index access, and the evaluator-only higher-order-
+callback lowering since Blade has no lambda expression).
+
+## Template output shape
+
+- `name: 'blade'`, `extension: '.blade.php'`, `templatesPerComponent: true` —
+  one `.blade.php` file per component, named by snake-casing the PascalCase
+  component name (`UserCard` → `user_card.blade.php`).
+- Hydration markers (`bf-s`, `bf-h`/`bf-m`/`bf-r`, `bf-p`, slot/conditional
+  comment markers, loop boundary comments) use the SAME runtime method
+  names as every other adapter's `bf.*` calls, spelled as PHP method calls
+  on the `$bf` variable (`$bf->scope_attr()`, `$bf->hydration_attrs()`,
+  `$bf->text_start`/`text_end`, `$bf->comment(...)`, …) — see
+  `spec/template-helpers.md` for the shared helper contract.
+- Every text/attribute interpolation of a possibly-non-string value is
+  routed through `$bf->string(...)` (or `$bf->bool_str(...)` for
+  boolean-shaped values); every non-comparison condition position is
+  routed through `$bf->truthy(...)`; every JS `===`/`!==` comparison routes
+  through `$bf->eq(...)`/`$bf->neq(...)` (PHP's own `==`/`===` are either
+  loose or number-representation-sensitive in ways that diverge from JS
+  strict equality). All are pure PHP-runtime helpers — see the PHP runtime
+  pointer below.
+
+## PHP runtime
+
+`php/src/` is a self-contained PHP package (dependencies: `illuminate/view`
+and `barefootjs/runtime`) implementing the engine-agnostic `bf` object
+every emitted template calls into: hydration markers, context propagation
+(`provide_context`/`use_context`), child-component rendering
+(`render_child`), script registration, and the JS-compatible helper
+library (`string`, `bool_str`, `truthy`, `number`, `floor`/`ceil`/`round`,
+array/string helpers, the `*_eval` evaluator helpers, `spread_attrs`,
+`query`, `eq`/`neq`, …). It mirrors the layering of
+`packages/adapter-perl/lib/` (an engine-agnostic core plus a thin
+per-engine backend) — see `spec/template-helpers.md` for the semantic
+contract each helper must satisfy, and the package's own tests under
+`php/tests/`.
+
+## Usage
+
+```ts
+// barefoot.config.ts
+import { createConfig } from '@barefootjs/blade/build'
+
+export default createConfig({
+  components: ['./src/components'],
+  outDir: './dist',
+})
+```
+
+`bf build` then emits `.blade.php` templates + client JS under `outDir`. A
+PHP host renders a component by constructing an `illuminate/view` `Factory`
+standalone (`Filesystem` + event `Dispatcher` + `EngineResolver` registering
+a `blade` engine over a `BladeCompiler` + `FileViewFinder`, all wired
+together by the `Factory` — see `php/src/BladeBackend.php`'s constructor)
+pointed at the emitted templates, wiring in the PHP `BladeBackend` as the
+render backend. Blade's `{{ }}` echo (`Illuminate\Support\e()`) emits named
+HTML entity forms (`"`/`'` via `ENT_QUOTES`) where Perl/Go/
+markupsafe emit the numeric `"`/`'` forms — see the adapter header
+comment for how that byte-form difference is handled.

package/dist/adapter/analysis/component-tree.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Component-tree analysis for the Blade template adapter.
+ *
+ * Ported from `packages/adapter-jinja/src/adapter/analysis/component-tree.ts`.
+ * Pure functions over the IR — they read no adapter instance state.
+ * `collectImportedLoopChildComponentErrors` returns its diagnostics instead
+ * of pushing onto the adapter's error list, so the adapter stays the sole
+ * owner of `errors`.
+ */
+import type { ComponentIR, CompilerError } from '@barefootjs/jsx';
+/**
+ * Whether the component needs the client runtime — it owns reactive state
+ * (signals / effects / onMount) or the analyzer flagged it as needing init.
+ */
+export declare function hasClientInteractivity(ir: ComponentIR): boolean;
+/**
+ * Build a `BF103` diagnostic for every component reference inside a loop body
+ * whose name is imported from a relative-path module. Mirror of the Go /
+ * Jinja adapter's check — the Blade adapter has the same
+ * cross-template-registration constraint at request time (each `.blade.php`
+ * component file must be registered with the shared Blade `Environment`
+ * loader alongside the parent). Returns the diagnostics so the caller pushes
+ * them onto its own error list.
+ */
+export declare function collectImportedLoopChildComponentErrors(ir: ComponentIR, componentName: string): CompilerError[];
+//# sourceMappingURL=component-tree.d.ts.map

package/dist/adapter/analysis/component-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-tree.d.ts","sourceRoot":"","sources":["../../../src/adapter/analysis/component-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,WAAW,EAUX,aAAa,EACd,MAAM,iBAAiB,CAAA;AAExB;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAO/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,uCAAuC,CACrD,EAAE,EAAE,WAAW,EACf,aAAa,EAAE,MAAM,GACpB,aAAa,EAAE,CAqEjB"}

package/dist/adapter/blade-adapter.d.ts

@@ -0,0 +1,537 @@
+/**
+ * BarefootJS Blade (PHP) Template Adapter
+ *
+ * Generates Laravel Blade template files (.blade.php) from BarefootJS IR.
+ *
+ * Near-mechanical port of the Twig (PHP) adapter
+ * (packages/adapter-twig/src/adapter/twig-adapter.ts) — itself a
+ * near-mechanical port of the Jinja2 adapter — from Twig syntax to Blade
+ * syntax. Both Twig and Blade render through PHP, so most of the JS/PHP
+ * semantic divergences documented in the Twig port CARRY OVER unchanged
+ * (truthiness, stringification, `bf`→`$bf->`-method-call routing, evaluator-
+ * JSON callbacks, `===`/`!==` via `eq`/`neq`, reserved-word mangling,
+ * in-template self-reference seeding). What's DIFFERENT is the surrounding
+ * template syntax — Blade compiles straight to raw PHP rather than its own
+ * expression language, so there is no `strict_variables: false` engine-wide
+ * forgiveness, no polymorphic `.`/`[]`, and every variable carries PHP's `$`
+ * sigil:
+ *
+ *   Twig `{{ EXPR }}` (escaped)            → Blade `{!! e(EXPR) !!}` — NOT bare `{{ EXPR }}` (see divergence 0 below: Blade's OWN `{{ }}` would be the natural mapping and DOES compile to `echo e(EXPR)`, but its compiler's regex-based tag matching breaks on evaluator-JSON payload text, so every escaped interpolation in THIS adapter's output explicitly spells out the same `e(...)` call under the `{!! !!}` delimiter instead)
+ *   Twig `{{ EXPR | raw }}`                → Blade `{!! EXPR !!}`
+ *   Twig `bf.method(args)`                 → Blade `$bf->method(args)`
+ *   Twig bare var `name`                   → Blade `$name` (mangled via `bladeIdent`/`bladeVar` — see divergence 1)
+ *   Twig `{% if C %}…{% elseif %}…{% else %}…{% endif %}` → Blade `@if(C)…@elseif(…)…@else…@endif`
+ *   Twig `{% for x in arr %}…{% endfor %}` → Blade `@foreach((arr ?? []) as $x)…@endforeach` (see divergence 2: raw PHP `foreach` over `null` warns, Twig's `strict_variables: false` didn't)
+ *   Twig `{% set x = e %}`                 → Blade `@php($x = e)`
+ *   Twig `{'k': v}` hash                    → Blade `['k' => v]` PHP array literal (still ALWAYS-quoted keys — see `lib/blade-naming.ts`)
+ *   Twig `~` concat                        → Blade `.` concat (same `$bf->string(...)` routing policy)
+ *   Twig `(t ? a : b)` ternary             → Blade same (PHP ternary, unchanged syntax)
+ *   Twig `l ?? r`                          → Blade same (PHP `??` also silences undefined-variable/index — see divergence 3)
+ *   Twig `bf.eq`/`bf.neq` for `===`/`!==`  → Blade `$bf->eq`/`$bf->neq` — NEVER PHP `==` (loose) nor `===` (`1 === 1.0` is `false` in PHP)
+ *   Twig `bf.truthy` in test positions     → Blade `$bf->truthy(...)` — same policy (PHP falsiness diverges from JS)
+ *   Twig `{% set NAME %}…{% endset %}` capture → Blade output buffering: `@php(ob_start())` … content … `@php($NAME = $bf->backend->mark_raw(preg_replace('/\n\z/', '', ob_get_clean(), 1)))` (see divergence 4)
+ *   Twig `.twig` files, `<snake_case>.twig` → Blade `.blade.php` files, `<snake_case>.blade.php` (`extension = '.blade.php'`)
+ *   Twig `a.b` / `a[i]` member/index access → Blade `data_get($a, 'b')` / `data_get($a, $i)` (see divergence 5 — the one place Twig's polymorphic `.` has no raw-PHP equivalent)
+ *   Twig evaluator-JSON `*_eval` payloads for callbacks → UNCHANGED — same mechanism, same shared `Barefoot\Evaluator`
+ *
+ * The render harness this adapter's output assumes: a Blade `Factory` wired
+ * from illuminate/view standalone (`Filesystem`, event `Dispatcher`,
+ * `EngineResolver` registering a `blade` engine over a `BladeCompiler`, a
+ * `FileViewFinder`, tied together by the `Factory`) — see
+ * `php/src/BladeBackend.php`'s constructor and file header for the exact
+ * wiring and the `Illuminate\Support\e()`/`Htmlable` escaping contract.
+ * Templates are named `<snake_case_component>.blade.php` (same convention as
+ * Twig's `.twig` files).
+ *
+ * **Whitespace policy.** Blade directives compile to raw `<?php … ?>` tags
+ * spliced into the surrounding template text — e.g. `@if(C)` compiles to
+ * `<?php if(C): ?>`. PHP itself has a well-known parser quirk: a `?>`
+ * closing tag immediately followed by exactly one newline has that ONE
+ * newline SWALLOWED (never emitted), independent of Blade. Verified
+ * empirically (`packages/adapter-blade/php`, standalone illuminate/view):
+ * rendering a template with `@if`/`@elseif`/`@else`/`@endif`,
+ * `@foreach`/`@endforeach`, and `@php(...)` lines EACH on their own source
+ * line at column 0 produces NO leaked blank lines around the directives —
+ * byte-identical in shape to Twig's `trim_blocks` behavior, but achieved for
+ * free via PHP's own tag-adjacent-newline rule rather than a Blade-specific
+ * feature. This gives the exact same uniform policy the Twig port already
+ * follows: **emit every directive at column 0 of its own source line, never
+ * introduce leading indentation before `@`.** No Blade-specific whitespace-
+ * control syntax is needed anywhere in this adapter.
+ *
+ * Divergences beyond the syntax table above (all uniform, not per-fixture —
+ * see the individual definition sites for the full rationale):
+ *
+ *   0. **CRITICAL — every escaped interpolation uses `{!! e(EXPR) !!}`, NEVER
+ *      Blade's own `{{ EXPR }}`.** Discovered empirically while porting the
+ *      evaluator-JSON callback fixtures (`.reduce`/`.sort`/`.filter` etc. —
+ *      divergence 8 below): `Illuminate\View\Compilers\Concerns\
+ *      CompilesEchos::compileRegularEchos` finds a `{{ … }}` pair with the
+ *      regex `/\{\{\s*(.+?)\s*\}\}(\r?\n)?/s` — a NON-GREEDY match against
+ *      the RAW TEMPLATE TEXT, with NO awareness of PHP string-literal
+ *      quoting. A serialized-`ParsedExpr` JSON payload for a NESTED
+ *      expression (e.g. `x => acc * x.qty`'s AST) routinely contains a
+ *      literal `}}` substring where one JSON object closes immediately
+ *      inside another (`...,"property":"qty"}}`) — even though that `}}` is
+ *      safely inside a single-quoted PHP string literal, Blade's regex does
+ *      not know that and terminates the `{{ … }}` tag AT THE FIRST `}}` IT
+ *      SEES, truncating the compiled PHP expression mid-string and producing
+ *      a syntax error (verified empirically — `BladeCompiler::compileString`
+ *      on `{{ $bf->string($bf->reduce_eval($items, '{"kind":"binary",
+ *      ...,"property":"qty"}}', ...)) }}` compiles to an unclosed-paren
+ *      fragment ending right after the first `}}`, confirmed via
+ *      `php -l` on the compiled output). Blade's raw-echo delimiter
+ *      (`{!! … !!}`) uses `!!}` as its closer, which this adapter's payload
+ *      text never produces (JSON output only ever contains `{`/`}`/quotes/
+ *      alphanumerics/punctuation, never `!`), so it is IMMUNE to this
+ *      failure mode. This adapter therefore NEVER emits Blade's own
+ *      escaped-echo delimiter — every position that needs HTML-escaped
+ *      output calls PHP's global `e()` helper (the SAME function `{{ }}`
+ *      would have called internally, imported for free via
+ *      `illuminate/support`'s composer "files" autoload — see
+ *      `BladeBackend.php`'s header for the `Htmlable` pass-through
+ *      contract, identical either way) explicitly under `{!! !!}` instead.
+ *      This is NOT a narrow, evaluator-only special case — it is applied
+ *      UNIFORMLY at every interpolation site in this file (text
+ *      expressions, attribute values, boolean-attribute ternaries, style
+ *      object values, the scope-id marker, template-literal attrs, provider
+ *      value propagation), because any one of them could in principle carry
+ *      an evaluator-JSON payload transitively, and a single missed
+ *      `{{ }}` site would silently reintroduce this failure mode for
+ *      whatever future fixture happens to nest two callback bodies deep
+ *      enough to trigger it.
+ *   1. **`$` sigil on every variable reference.** Twig identifiers have no
+ *      sigil; Blade compiles to raw PHP, where every variable — read OR
+ *      `@php(...)` assignment target — is `$name`. `bladeIdent(name)`
+ *      (`lib/blade-naming.ts`) mirrors `twigIdent`'s mangling-only role
+ *      (bare name, no `$`); `bladeVar(name)` is the NEW wrapper used at
+ *      every actual variable-reference emission site. See
+ *      `expr/emitters.ts`'s file header for the full rundown of every
+ *      emitter call site this affects.
+ *   2. **`@foreach` needs an explicit null/undefined guard Twig didn't.**
+ *      Twig's `{% for %}` over `strict_variables: false` tolerated an
+ *      unbound/`null` array (zero iterations, no error). Raw PHP's
+ *      `foreach (null as $x)` raises a `TypeError` (PHP 8) /
+ *      `Warning: Invalid argument` (older PHP) — verified empirically. This
+ *      adapter therefore ALWAYS wraps the loop array in `(EXPR ?? [])`,
+ *      matching Twig's tolerance uniformly rather than per-fixture.
+ *   3. **`??` is PHP-native and REPLACES Twig's `strict_variables: false`
+ *      forgiveness with a per-use-site policy.** PHP's `??` silences BOTH
+ *      an undefined-variable/-array-index notice AND a real `null` in ONE
+ *      operator (verified empirically: `$missing ?? 'fb'` and `$x ?? 'fb'`
+ *      with `$x = null` both yield `'fb'`, no warning) — same coverage
+ *      Twig's native `??` gave (this adapter's divergence 3 in the Twig
+ *      port), but Blade has no engine-wide switch equivalent to
+ *      `strict_variables: false`; every place a possibly-unbound var is
+ *      read (nullable-optional-prop guards, the `Record[key]` lookup
+ *      fallback) uses `??`/`isset()` explicitly at that site instead — see
+ *      divergence 6 below for the SEPARATE "omit the attribute entirely"
+ *      case `??` alone doesn't cover.
+ *   4. **Children/fallback capture via output buffering, not a set-block —
+ *      and NEVER Blade's bare `@php … @endphp` block form.** Blade has no
+ *      Twig-set-block equivalent that captures arbitrary rendered TEMPLATE
+ *      OUTPUT (as opposed to a single PHP expression's value) into a
+ *      variable. This adapter uses ONE uniform mechanism instead — PHP's
+ *      own output buffering: `@php(ob_start())` … the captured body,
+ *      rendered normally (so any interpolation inside is escaped exactly as
+ *      if it rendered inline) …
+ *      `@php($NAME = $bf->backend->mark_raw(preg_replace('/\n\z/', '', ob_get_clean(), 1)))`.
+ *      Two things beyond the ob_start/ob_get_clean shape itself:
+ *        (a) the trailing `preg_replace('/\n\z/', '', …, 1)` strips exactly
+ *            the ONE newline this adapter's own template-string builder
+ *            inserts between the captured body and the closing `@php(...)`
+ *            line (needed so the directive is preceded by a non-word
+ *            character — Blade's directive regex is `\B@word`, which
+ *            requires the '@' NOT be glued directly onto a preceding word
+ *            character) — without this trim, that synthetic newline is
+ *            itself part of the captured buffer and leaks into the
+ *            rendered HTML as extra whitespace right before the next
+ *            sibling/closing tag (caught by the adapter-conformance suite:
+ *            `<h2>Create New Task</h2>` rendering as `...Task </h2>` — a
+ *            newline that `normalizeHTML` collapses to a visible trailing
+ *            space). The trim is bounded to exactly one synthetic
+ *            newline, not `rtrim`-style — content the caller genuinely
+ *            renders with real trailing newlines keeps them.
+ *        (b) this adapter uses ONLY the single-expression `@php(EXPR)`
+ *            directive form, NEVER the bare `@php` / `@endphp` BLOCK form,
+ *            anywhere in its emitted templates — verified empirically that
+ *            `BladeCompiler::compileString` mishandles a `@php(EXPR)`
+ *            occurrence EARLIER in the same template when a bare
+ *            `@php ... @endphp` block appears LATER in it (the directive-
+ *            matching regex's paren-balancing recovery walk gets confused
+ *            by the later bare `@php` token, leaving `@php(EXPR)` OR its
+ *            inner expression malformed/uncompiled). Since this adapter
+ *            cannot control what OTHER templates its output might be
+ *            concatenated/co-rendered alongside, every capture site stays
+ *            on the single-expression form exclusively, sidestepping the
+ *            whole class of mixed-form parsing quirks.
+ *      `mark_raw` wraps the captured string in an `HtmlString`, so a later
+ *      plain `{{ $NAME }}` echo does NOT re-escape it (verified empirically
+ *      — same "capture once, emit raw once" contract Twig's set-block gave,
+ *      see `BladeBackend.php`'s header for why `Illuminate\Support\e()`
+ *      makes this work). Every set-block capture site in the Twig port
+ *      (`renderComponent`'s children forward, `renderAsync`'s fallback)
+ *      maps onto this ONE mechanism here too — always invoked immediately,
+ *      in place, with zero arguments, never reused/invoked lazily.
+ *   5. **Member/index access lowers to `data_get(...)`, not `.`/`[]`.**
+ *      Twig's `.`/`[]` are polymorphic over {stdClass, array, null} under
+ *      `strict_variables: false`; raw PHP has NO single operator with that
+ *      property (`$x->prop` fatals on a non-object, `$x['key']` warns on
+ *      `null`/scalar). This adapter uses Laravel's `data_get($target, $key)`
+ *      (from `illuminate/support`, already a transitive dependency of
+ *      `illuminate/view` — no NEW runtime dependency, no change to
+ *      `packages/adapter-php`) uniformly for both member access (`a.b` →
+ *      `data_get($a, 'b')`) and index access (`a[i]` → `data_get($a, $i)`)
+ *      — verified null-safe over the SAME {stdClass, array, null} value
+ *      shapes Twig's dot/bracket cover (see `lib/blade-naming.ts`'s
+ *      `bladeMemberAccess`/`bladeIndexAccess` docstrings for the verification
+ *      transcript). This is the ONE place this port required a genuinely new
+ *      lowering strategy rather than a mechanical syntax substitution.
+ *   6. **Nullable-optional-prop attribute omission uses `isset($x)`, a
+ *      SINGLE check — simpler than Twig's TWO-part `is defined and is not
+ *      null`.** Twig needed both tests because `is defined` and `is not
+ *      none` are separate concerns under `strict_variables: false`. PHP's
+ *      `isset($x)` already returns `false` for BOTH "never extracted into
+ *      scope" AND "extracted as `null`" in one call (verified empirically —
+ *      `isset($rows)` is `false` whether `$rows` was omitted from the
+ *      render-vars array entirely or passed as `null`; `true` only when
+ *      bound to a non-null value) — so this adapter's `elementAttrEmitter`
+ *      guards with `@if(isset($x)) … @endif` instead of a two-part test.
+ *   7. **`===`/`!==` route through `$bf->eq`/`$bf->neq`, NEVER PHP's own
+ *      `==`/`!=`/`===`/`!==`.** Unchanged from the Twig port's divergence 4
+ *      — PHP's `==` is loose (`'1' == 1` is `true`), and PHP's OWN `===` is
+ *      wrong the OTHER direction (`1 === 1.0` is `false` in PHP; JS has one
+ *      number type, so `1 === 1.0` is `true`). See `expr/emitters.ts`'s file
+ *      header for the full rationale.
+ *   8. **No Blade lambda** (`expr/emitters.ts` header, divergence 9).
+ *      Unchanged from Twig — every higher-order callback routes through the
+ *      evaluator-JSON `*_eval` payload; an unserializable predicate surfaces
+ *      `BF101`. `.sort`'s non-lambda STRUCTURED fallback (`$bf->sort` with a
+ *      `['keys' => […]]` descriptor) is unaffected and ports unchanged.
+ *   9. **Reserved-word mangling set is COMPLETELY DIFFERENT from Twig's, for
+ *      a different reason** (`lib/blade-naming.ts`). Twig keywords (`for`,
+ *      `filter`, `if`, …) collide with TWIG'S OWN grammar — irrelevant here,
+ *      since Blade template vars are real PHP variables bound via
+ *      `extract()` (`$for`, `$filter` are perfectly legal). What collides
+ *      instead is the Blade/illuminate RENDER-TIME PHP SCOPE: `bf` (the
+ *      runtime binding), `this` (PHP forbids `$this` reassignment),
+ *      `__env`/`__data`/`__path` (illuminate/view internals), `app`
+ *      (conventional container binding), `loop` (Blade's own `@foreach`
+ *      `$loop`). `blade_ident()` in PHP (`php/src/naming.php`);
+ *      `BladeBackend::ident()` delegates to it. Mirrored exactly by
+ *      `bladeIdent`/`RESERVED_WORDS` on the TS side, with a parity test on
+ *      each side (port of the Twig adapter's parity test).
+ *  10. **Blade's own `$loop->index`, not `loop.index0`.** Both engines
+ *      expose a 0-based per-iteration index via a builtin loop object —
+ *      verified empirically Blade's is `$loop->index` (property, not a
+ *      method), coincidentally same 0-based numbering as Twig's
+ *      `loop.index0`, just a different property name and `->` access.
+ *  11. **`array_merge(...)`, not a chained `|merge` filter, for ordered
+ *      component-prop segments.** Twig has no hash-splat syntax, so the
+ *      Twig port folds `{...before, ...spread, after: 1}` JSX spread
+ *      semantics through repeated `{a}|merge({b})|merge({c})` filter calls.
+ *      PHP's `array_merge` is natively variadic AND already resolves later-
+ *      argument-wins on string-key conflict (verified empirically — same
+ *      semantics `Object.assign`/JSX spread order needs), so this adapter
+ *      folds the segment list into ONE `array_merge($seg1, $seg2, …)` call
+ *      instead of a chain — simpler, not just a syntax reshuffle.
+ */
+import type { ComponentIR, IRNode, IRElement, IRText, IRExpression, IRConditional, IRLoop, IRComponent, IRFragment, IRSlot, IRIfStatement, IRProvider, IRAsync, TemplatePrimitiveRegistry } from '@barefootjs/jsx';
+import { BaseAdapter, type AdapterOutput, type AdapterGenerateOptions, type IRNodeEmitter, type EmitIRNode } from '@barefootjs/jsx';
+import type { BladeRenderCtx } from './lib/types.ts';
+export type { BladeAdapterOptions } from './lib/types.ts';
+import type { BladeAdapterOptions } from './lib/types.ts';
+export declare class BladeAdapter extends BaseAdapter implements IRNodeEmitter<BladeRenderCtx> {
+    name: string;
+    extension: string;
+    templatesPerComponent: boolean;
+    importMapInjection: 'html-snippet';
+    /**
+     * Identifier-path callees the Blade runtime can render in template scope.
+     * The relocate pass consults this map to mark matching calls as
+     * template-safe; the SSR template emitter substitutes the JS call with the
+     * registered `$bf->NAME(...)` helper invocation.
+     */
+    templatePrimitives: TemplatePrimitiveRegistry;
+    private componentName;
+    /** Component root scope element(s) — each carries `data-key` for a keyed loop
+     *  item (set by the child renderer from the JSX `key` prop). A plain element
+     *  root is one node; an `if-statement` (early-return) root contributes the
+     *  top element of every branch. */
+    private rootScopeNodes;
+    private options;
+    private errors;
+    private inLoop;
+    /**
+     * SolidJS-style props identifier (`function(props: P)`) and the
+     * analyzer-extracted prop names. Stashed at `generate()` entry so the
+     * per-attribute `emitSpread` callback can build a propsObject spread bag as
+     * an inline PHP array literal without re-walking the IR.
+     */
+    private propsObjectName;
+    private propsParams;
+    private booleanTypedProps;
+    /**
+     * Names (signal getters + props) whose value is a string. Carried for
+     * parity with the Perl-family adapters (Mojo needs it for `eq`/`ne`
+     * selection); the Blade emitters don't consume it — `===`/`!==` always
+     * routes through `$bf->eq`/`$bf->neq` regardless of operand type (see
+     * `blade-adapter.ts`'s file header, divergence 7).
+     */
+    private stringValueNames;
+    /**
+     * Module-scope pure-string consts (`const x = 'literal'`), keyed by name →
+     * unescaped value. A className template literal that references such a const
+     * (`className={`${x} ${className}`}`) must inline the literal: the const is
+     * module-scope, so it never reaches the per-render context, and a bare
+     * reference to `x` would resolve to an undefined variable.
+     */
+    private moduleStringConsts;
+    /**
+     * (#1922) Local binding names the request-scoped `searchParams()` env signal
+     * is imported under (handles `import { searchParams as sp }`). When non-empty
+     * the emitter lowers a `<binding>().get(k)` call to a real method call on the
+     * per-request `searchParams` reader (`$searchParams->get('sort')`) instead of
+     * the generic `data_get` deref. Set at `generate()` entry from
+     * `ir.metadata.imports`; read by the top-level ParsedExpr emitter.
+     */
+    private _searchParamsLocals;
+    /**
+     * Call-lowering matchers active for this component (#2057). Bound at
+     * `generate()` entry via `prepareLoweringMatchers` and read by the top-level
+     * emitter. Covers both userland plugins and the compiler's built-in plugins
+     * (e.g. `queryHref` → `$bf->query`, #2042) — one uniform path, no per-API branch.
+     */
+    private _loweringMatchers;
+    /**
+     * Local + module constants from the IR, used by the conditional-spread and
+     * `Record<staticKeys, scalar>[propKey]` lowering paths (#textarea / #checkbox).
+     * Stashed at `generate()` entry so `emitSpread` can resolve a bare local
+     * const (`const sizeAttrs = size ? {…} : {}`) to its initializer text.
+     */
+    private localConstants;
+    /**
+     * Optional, no-default props that are `None` when the caller omits them.
+     * Their bare-reference attribute emission is guarded with a Blade
+     * `isset($x)` test so the attribute DROPS rather than rendering `attr=""`
+     * (Hono-style nullish omission, e.g. textarea's `rows`; see this file's
+     * header, divergence 6). The filter excludes destructure-defaulted, rest,
+     * and concrete-primitive props.
+     */
+    private nullableOptionalProps;
+    constructor(options?: BladeAdapterOptions);
+    generate(ir: ComponentIR, options?: AdapterGenerateOptions): AdapterOutput;
+    private generateScriptRegistrations;
+    /**
+     * Public entry point for node rendering. Delegates to the shared
+     * `IRNodeEmitter` dispatcher; per-kind logic lives in the `IRNodeEmitter`
+     * methods below.
+     */
+    renderNode(node: IRNode): string;
+    emitElement(node: IRElement, _ctx: BladeRenderCtx, _emit: EmitIRNode<BladeRenderCtx>): string;
+    emitText(node: IRText): string;
+    emitExpression(node: IRExpression): string;
+    emitConditional(node: IRConditional, _ctx: BladeRenderCtx, _emit: EmitIRNode<BladeRenderCtx>): string;
+    emitLoop(node: IRLoop, _ctx: BladeRenderCtx, _emit: EmitIRNode<BladeRenderCtx>): string;
+    emitComponent(node: IRComponent, _ctx: BladeRenderCtx, _emit: EmitIRNode<BladeRenderCtx>): string;
+    emitFragment(node: IRFragment, _ctx: BladeRenderCtx, _emit: EmitIRNode<BladeRenderCtx>): string;
+    emitSlot(node: IRSlot): string;
+    emitIfStatement(node: IRIfStatement, _ctx: BladeRenderCtx, _emit: EmitIRNode<BladeRenderCtx>): string;
+    emitProvider(node: IRProvider, _ctx: BladeRenderCtx, _emit: EmitIRNode<BladeRenderCtx>): string;
+    /** Lower a `<Ctx.Provider value>` value prop to a Blade expression. */
+    private providerValueBlade;
+    /**
+     * Lower an object-literal provider value (`value={{ open: () => props.open
+     * ?? false, onOpenChange: … }}`) to a PHP array literal (#1897). The
+     * SSR lowering is a per-member snapshot of what a consumer would READ
+     * during the same render:
+     *
+     * - zero-param expression-body arrows are getters — lower the body (the
+     *   value is fixed for the render, so the call-time indirection drops out)
+     * - `on[A-Z]`-named members and function-shaped values are client-only
+     *   behavior SSR never invokes — lower to `null`
+     * - anything else lowers through the normal expression pipeline (so an
+     *   unsupported getter body still refuses loudly with BF101)
+     *
+     * Keys keep their JS names verbatim so a consumer-side `ctx.open` access
+     * maps onto the same array key. Returns `null` when the expression is not a
+     * plain object literal (spread / computed key) — the caller falls back to
+     * the whole-expression path, which refuses those shapes with BF101.
+     */
+    private providerObjectLiteralBlade;
+    emitAsync(node: IRAsync, _ctx: BladeRenderCtx, _emit: EmitIRNode<BladeRenderCtx>): string;
+    renderElement(element: IRElement): string;
+    renderExpression(expr: IRExpression): string;
+    renderConditional(cond: IRConditional): string;
+    private renderNodeOrNull;
+    /**
+     * Add bf-c attribute to the first HTML element in a branch.
+     * If no element found, wrap with comment markers.
+     */
+    private addCondMarkerToFirstElement;
+    renderLoop(loop: IRLoop): string;
+    /**
+     * AttrValue lowering for component invocation props (Blade array-entry
+     * form). Blade/PHP CANNOT splat an array into positional args, so every
+     * prop is emitted as a `'key' => value` entry that the caller collects
+     * into ONE array literal passed to `$bf->render_child(name, [ ... ])`.
+     *
+     * `jsx-children` returns empty — children are captured via the output-
+     * buffering mechanism below, not threaded through the entry list.
+     */
+    private readonly componentPropEmitter;
+    /**
+     * A `renderComponent` props array, built as an ORDERED sequence of
+     * segments so `{...before, ...spread, after: 1}` JSX spread semantics
+     * (later entries win) survive the trip through Blade/PHP, which has no
+     * array-splat call syntax. Each `'entries'` segment is a literal PHP
+     * array `[k => v, ...]`; each `'spread'` segment is an arbitrary
+     * expression lowered from a `{...expr}` prop. `combineComponentPropSegments`
+     * folds the sequence into ONE expression via `array_merge(...)` (later
+     * segment wins on key conflict, matching `Object.assign`/JSX order — see
+     * this file's header, divergence 11).
+     */
+    private componentPropSegmentEntries;
+    /**
+     * Fold ordered prop segments into a single PHP expression via ONE
+     * variadic `array_merge(...)` call — later argument wins on string-key
+     * conflict, exactly like `{...a, ...b}` (verified empirically). Empty
+     * `'entries'` segments are dropped so a leading/trailing spread doesn't
+     * drag in a needless `[]` argument. Returns `'[]'` when every segment is
+     * empty (no props at all); returns the lone segment directly (no
+     * `array_merge` wrapper) when there is exactly one.
+     */
+    private combineComponentPropSegments;
+    renderComponent(comp: IRComponent): string;
+    private childrenCaptureCounter;
+    /** Uniquifies the `presenceOrUndefined` temp binding (`bf_puN`) so two
+     *  presence-folded attrs in one template don't collide. */
+    private presenceVarCounter;
+    private toTemplateName;
+    private renderIfStatement;
+    private renderFragment;
+    private renderSlot;
+    renderAsync(node: IRAsync): string;
+    /**
+     * AttrValue lowering for intrinsic-element attributes (Blade).
+     */
+    private readonly elementAttrEmitter;
+    /**
+     * Lower a `style={{ … }}` object literal to a CSS string with dynamic values
+     * interpolated as Blade expressions, e.g. `{ backgroundColor: color }` →
+     * `background-color:{{ $bf->string($color) }}`. Returns null when the shape
+     * is unsupported or any value can't be lowered (caller falls through to
+     * BF101). (#1322)
+     */
+    private tryLowerStyleObject;
+    /** HTML-attribute escape for static text inlined into a `"..."` attribute. */
+    private escapeAttrText;
+    private renderAttributes;
+    renderScopeMarker(_instanceIdExpr: string): string;
+    renderSlotMarker(slotId: string): string;
+    renderCondMarker(condId: string): string;
+    /**
+     * Convert a ParsedExpr AST to a Blade expression string for filter
+     * predicates. Wraps the shared ParsedExpr dispatcher with a
+     * `BladeFilterEmitter` carrying the predicate's loop param and any
+     * block-body local var aliases.
+     */
+    private renderBladeFilterExpr;
+    private convertTemplateLiteralPartsToBlade;
+    /**
+     * Translate `${EXPR}` interpolations in a static template-part string into
+     * Blade variable references and concatenate them with the surrounding
+     * literal text. Each interpolated (non-literal) segment routes through
+     * `$bf->string(...)` — see the file header, "Stringification".
+     */
+    private substituteJsInterpolationsToBlade;
+    /**
+     * Refuse JS expression shapes that have no idiomatic Blade representation:
+     * object literals (`style={{...}}`) and tagged-template-literal call
+     * expressions (`cn\`base \${tone()}\``). Records `BF101`. Returns `true`
+     * when the shape was rejected (caller should drop the attribute).
+     */
+    private refuseUnsupportedAttrExpression;
+    /**
+     * Build the EmitContext seam the top-level `ParsedExpr` emitter depends on.
+     * Built as a private object (the adapter does NOT `implements BladeEmitContext`)
+     * so the wrapped bookkeeping — `_searchParamsLocals`, the const/record
+     * resolvers, BF101 recording, the filter-predicate entry — stays private and
+     * off the exported adapter's public type, matching the Go adapter's
+     * `emitCtx` and the `spreadCtx` / `memoCtx` seams below.
+     */
+    private get emitCtx();
+    /**
+     * Build the narrow context the extracted spread lowering depends on. Passing
+     * a purpose-built object (rather than `this`) keeps the adapter's bookkeeping
+     * members private — they stay internal implementation detail, not part of the
+     * exported class's public surface.
+     */
+    private get spreadCtx();
+    /** Build the narrow context the extracted memo seeding depends on. */
+    private get memoCtx();
+    private convertExpressionToBlade;
+    /**
+     * Convert a JS condition (an `if` / ternary / loop-filter test) to a Blade
+     * boolean expression, routing through `$bf->truthy(...)` unless the
+     * expression is structurally already boolean-shaped. See the file header,
+     * "JS truthiness".
+     */
+    private convertConditionToBlade;
+    /**
+     * Shared helper: given the ORIGINAL JS expression (or its already-parsed
+     * tree) and its ALREADY-RENDERED Blade text, wrap the rendered text with
+     * `$bf->truthy(...)` unless the expression is structurally boolean-shaped.
+     * Split from `convertConditionToBlade` so a caller that already lowered the
+     * expression for another purpose (e.g. the `presenceOrUndefined` temp bind)
+     * doesn't lower it twice.
+     */
+    private wrapConditionExpr;
+    /**
+     * Render a full ParsedExpr tree to Blade for top-level (non-filter)
+     * expressions where identifiers are signals / template vars.
+     */
+    private renderParsedExprToBlade;
+    /** Whether `name` (a signal getter or prop) holds a string value. Carried
+     *  for parity with the Perl-family adapters; the Blade emitters don't
+     *  consume it (`===`/`!==` always routes through `$bf->eq`/`$bf->neq`
+     *  regardless of operand type). */
+    private _isStringValueName;
+    /**
+     * Parse `cond ? value : undefined` (or `: null`), returning the
+     * condition/consequent source spans, else `null`. Used for the
+     * attribute-omission rule (#1897).
+     */
+    parseUndefinedAlternateTernary(expr: string): {
+        condition: string;
+        consequent: string;
+    } | null;
+    isBooleanTypedPropRef(expr: string): boolean;
+    /**
+     * Whether an attribute-value expression should route through
+     * `$bf->bool_str` (vs. plain `$bf->string`) at its interpolation site.
+     * `isExplicitStringCall` is checked FIRST and short-circuits the other
+     * three: an explicit `String(x)` call already lowers to `$bf->string(x)`,
+     * which correctly stringifies a real boolean on its own (see the PHP
+     * runtime's `string()` helper's bool branch), so layering `$bf->bool_str`
+     * on top would run PHP truthiness over the ALREADY-STRINGIFIED text
+     * instead of the original boolean. See `isExplicitStringCall`'s docstring
+     * in `boolean-result.ts` for the full double-wrap failure mode this
+     * guards against.
+     */
+    private shouldBoolStr;
+    /**
+     * Inline a const (any scope) whose initializer is a pure numeric or
+     * single-quoted string literal (`const totalPages = 5`, #1897
+     * pagination) — function-scope consts never reach the per-render
+     * context, so a bare reference would resolve to an undefined variable.
+     */
+    private _resolveLiteralConst;
+    private _resolveStaticRecordLiteral;
+    private _resolveModuleStringConst;
+    private _recordExprBF101;
+    /** Internal hook for higher-order: predicate body re-uses the filter emitter. */
+    private _renderBladeFilterExprPublic;
+}
+export declare const bladeAdapter: BladeAdapter;
+//# sourceMappingURL=blade-adapter.d.ts.map

package/dist/adapter/blade-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blade-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter/blade-adapter.ts"],"names":[],"mappings":"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"}