@barefootjs/blade 0.1.0

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

@@ -0,0 +1,128 @@
+/**
+ * Blade/PHP identifier, hash-key, and member/index-access conventions for
+ * the Blade adapter.
+ *
+ * Ported from `packages/adapter-twig/src/adapter/lib/twig-naming.ts`
+ * (`twigIdent`/`twigHashKey`/`twigLoopBindingAccessor`), adjusted for the
+ * real syntax divergences between Twig and Blade that matter here:
+ *
+ * 1. **Every variable reference needs the `$` sigil.** Twig has no sigil —
+ *    `twigIdent(name)` returned the bare (possibly mangled) name, used
+ *    directly as both a read and a `{% set %}` assignment target. Blade
+ *    compiles straight to raw PHP, where every variable — read OR write —
+ *    is `$name`. `bladeIdent(name)` (this file) mirrors `twigIdent`'s
+ *    mangling-only role (used for the PHP array KEY a prop is threaded
+ *    through as, e.g. `naming.php`'s `blade_ident`); `bladeVar(name)` is the
+ *    NEW wrapper that additionally prepends `$` — every place the Blade
+ *    adapter emits a bare variable REFERENCE (identifier read, loop-binding
+ *    `@php($x = ...)` target, hash-entry value, …) uses `bladeVar`, not
+ *    `bladeIdent` alone.
+ * 2. **Hash-literal keys are always quoted, but the literal itself is a PHP
+ *    array, not a Twig hash.** `{'k': v}` → `['k' => v]` (mapping table) —
+ *    `bladeHashKey` still always quotes (same bareword-key trap Twig/Jinja
+ *    have), but every CALL SITE joins entries with `=>` and wraps them in
+ *    `[...]`, never `{...}` / `: `.
+ * 3. **Member/index access has no raw-PHP polymorphic equivalent.** Twig's
+ *    `.`/`[]` transparently resolve an object property, an array key, OR a
+ *    getter method on ANY of {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, and dynamic keys need yet another form. This adapter
+ *    uses Laravel's `data_get($target, $key)` (from `illuminate/support`,
+ *    already a transitive dependency of `illuminate/view`) uniformly for
+ *    BOTH member access (`a.b` → `data_get($a, 'b')`) and index access
+ *    (`a[i]` → `data_get($a, $i)`) — verified empirically (see
+ *    `bladeMemberAccess`'s docstring) to be null-safe over the same
+ *    {stdClass, array, null} value shapes Twig's dot/bracket cover, with NO
+ *    runtime helper added to `packages/adapter-php` (the `data_get`
+ *    lowering point is entirely on the TS emit side).
+ * 4. **Reserved-word set is COMPLETELY DIFFERENT, and for a different
+ *    reason.** Twig keywords (`for`, `filter`, `if`, …) collide with Twig's
+ *    OWN expression grammar — irrelevant here, since Blade variables are
+ *    real PHP variables (`$for`, `$filter` are legal). What collides
+ *    instead is anything the Blade/illuminate RENDER-TIME PHP SCOPE already
+ *    binds to a different meaning, or a name PHP itself forbids — see
+ *    `RESERVED_WORDS`'s docstring below and `php/src/naming.php`'s (this
+ *    adapter's PHP-side twin, which MUST mirror this list exactly; each
+ *    side carries a parity test against the other).
+ */
+import type { LoopBindingPathSegment } from '@barefootjs/jsx';
+/**
+ * Escape a string for a PHP/Blade single-quoted literal: backslash first (so
+ * it doesn't double-escape the quote we add next), then the quote. PHP's
+ * single-quoted string escaping rules are `\\` and `\'` ONLY (verified:
+ * `php -r "echo 'a\\'b';"` → `a'b`) — byte-identical to Twig's own
+ * single-quoted escaping, so this function's body is unchanged from
+ * `escapeTwigSingleQuoted`.
+ */
+export declare function escapeBladeSingleQuoted(s: string): string;
+/**
+ * Quote an array-literal KEY for Blade/PHP. Always quotes — a bareword key
+ * in a PHP array literal (`[key => value]`) is a syntax error, not a
+ * variable lookup (unlike Twig's hash literal, where an unquoted key reads
+ * as a variable reference) — but this adapter quotes unconditionally anyway
+ * for one uniform rule across every adapter in the family (mirrors
+ * `twigHashKey`/`jinjaHashKey`).
+ */
+export declare function bladeHashKey(name: string): string;
+/**
+ * Mangle a JS identifier (prop name, signal getter, loop param, …) into a
+ * Blade-safe NAME: reserved words get a trailing `_` suffix, everything else
+ * passes through unchanged. This is the BARE (no `$`) form — used for a PHP
+ * array KEY a prop is threaded through as (`naming.php`'s `blade_ident`,
+ * `BladeBackend::render_named`'s per-prop mangling). Every place the adapter
+ * emits an actual Blade VARIABLE REFERENCE uses `bladeVar` (below), which
+ * wraps this with the `$` sigil Twig's `twigIdent` never needed.
+ */
+export declare function bladeIdent(name: string): string;
+/**
+ * Mangle a JS identifier into a Blade VARIABLE REFERENCE (`$name` or
+ * `$name_` when reserved) — the sigil-bearing counterpart of `bladeIdent`,
+ * used at every point the adapter emits a bare variable read OR a
+ * `@php($NAME = ...)` assignment target (mirrors every `twigIdent(...)`
+ * call site in the Twig port, since Twig had no sigil to add).
+ */
+export declare function bladeVar(name: string): string;
+/**
+ * Member access lowering: `a.b` → `data_get($a, 'b')`. Uniform, null-safe
+ * over `stdClass` (JSON-decoded objects), PHP assoc arrays (runtime helper
+ * outputs), and `null` — verified empirically:
+ *
+ *   php -r 'require "vendor/autoload.php";
+ *     $o = json_decode("{\"a\":{\"b\":1}}");
+ *     var_dump(data_get($o, "a.b"));        // int(1)
+ *     var_dump(data_get($o, "missing.x"));  // NULL (no warning)
+ *     var_dump(data_get(null, "a.b"));      // NULL (no warning)'
+ *
+ * `data_get` treats a key with no `.` as ONE top-level segment (not a
+ * multi-hop path), so a literal property name that itself happens to
+ * contain a `.` character would be misread as a nested path — accepted as a
+ * known, narrow limitation (JS field/prop names essentially never contain a
+ * literal dot; no adapter-conformance fixture does).
+ */
+export declare function bladeMemberAccess(objectExpr: string, property: string): string;
+/**
+ * Index access lowering: `a[i]` → `data_get($a, $i)`. `data_get` accepts a
+ * non-string (int, or a PHP expression evaluating to int/string) segment
+ * directly — verified empirically: `data_get(['a','b','c'], $i)` with
+ * `$i = 1` → `'b'`. Same null-safety as `bladeMemberAccess`.
+ */
+export declare function bladeIndexAccess(objectExpr: string, indexExpr: string): string;
+/**
+ * Build a Blade/PHP accessor expression that walks a `.map()` destructure
+ * binding's structured `segments` path (#2087 Phase A, `LoopBindingPathSegment`)
+ * off `base` — the per-iteration loop var (`$__bf_item`) for a fixed binding
+ * or a top-level rest binding, or an already-built PARENT accessor for a
+ * nested rest binding (`segments` there is the prefix up to, not including,
+ * the rest token).
+ *
+ * UNLIKE `twigLoopBindingAccessor` (which branches on bracket-subscript vs.
+ * dot-access vs. the `attribute()` builtin depending on whether a `field`
+ * segment's key is identifier-safe), every segment here — `index` OR `field`,
+ * ident-safe or not — routes through the SAME uniform `data_get` accessor
+ * (see the file header, divergence 3): there is no raw-PHP polymorphic
+ * operator to special-case around in the first place, so there is nothing to
+ * branch on. This is strictly SIMPLER than the Twig port.
+ */
+export declare function bladeLoopBindingAccessor(base: string, segments: readonly LoopBindingPathSegment[]): string;
+//# sourceMappingURL=blade-naming.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blade-naming.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/blade-naming.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAA;AAE7D;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAwBD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,SAAS,sBAAsB,EAAE,GAC1C,MAAM,CAQR"}

package/dist/adapter/lib/constants.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Compile-time constant tables for the Blade template adapter.
+ *
+ * Ported from `packages/adapter-jinja/src/adapter/lib/constants.ts`.
+ */
+import type { PrimitiveSpec } from './types.ts';
+/**
+ * Single source of truth for the Blade adapter's template-primitive surface.
+ * Each entry pairs the expected arity with the emit function.
+ *
+ * The emit fn returns a Blade/PHP expression (no surrounding `{{ }}`)
+ * suitable for embedding inside an interpolation — `$bf->json($val)`,
+ * `$bf->floor($val)`, etc. Same primitive names and keys as the Jinja/Twig
+ * adapters; every `bf.xxx(...)` call becomes `$bf->xxx(...)` (mapping table).
+ */
+export declare const BLADE_TEMPLATE_PRIMITIVES: Record<string, PrimitiveSpec>;
+/**
+ * Module-scope `templatePrimitives` map derived once from the spec record.
+ */
+export declare const BLADE_PRIMITIVE_EMIT_MAP: Record<string, (args: string[]) => string>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/adapter/lib/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE/C;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAOnE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,CAG7E,CAAA"}

package/dist/adapter/lib/ir-scope.d.ts

@@ -0,0 +1,48 @@
+/**
+ * IR traversal helpers for the Blade template adapter.
+ *
+ * Ported from `packages/adapter-twig/src/adapter/lib/ir-scope.ts`.
+ * `resolveJsxChildrenProp` and `collectRootScopeNodes` are byte-identical
+ * (adapter-agnostic IR walks).
+ *
+ * `extractTopLevelIdentifiers` is SIMPLER than the Twig port's. Twig
+ * identifiers have no sigil, so that port had to strip quoted strings first,
+ * exclude dotted property/method names, and drop a closed set of Twig-
+ * grammar keywords the adapter's own codegen could emit (`is`, `defined`,
+ * `and`, `not`, `null`, `true`, `false`, `bf`) to avoid false-matching one of
+ * those as a genuine context-var reference. Blade variables carry PHP's `$`
+ * sigil — the SAME property that made Kolon's own `\$([A-Za-z_]\w*)` scan
+ * trivially safe (see the Twig port's file header, which calls this out
+ * explicitly as the thing Twig's sigil-less grammar lacked). So this port
+ * needs no quote-stripping, no dotted-name exclusion (member/index access
+ * here is `data_get(...)`, a function call, not a `.`/`[]` postfix that
+ * could attach to a preceding bare word), and no keyword-exclusion set at
+ * all — the ONLY non-context-var `$name` this adapter's own codegen ever
+ * emits is `$bf` (the runtime handle), excluded explicitly below.
+ */
+import type { IRNode, IRProp } from '@barefootjs/jsx';
+/**
+ * Extract the set of "top-level identifier" tokens (bare `$name` references,
+ * `$bf` excluded) from a rendered Blade expression. `memo/seed.ts` uses this
+ * to detect a constant lowering (no real variable reference at all) that
+ * should keep the static ssr-defaults seed instead of an in-template
+ * `@php($x = ...)`; scope AVAILABILITY itself is the shared
+ * `computeSsrSeedPlan`'s job (packages/jsx/src/ssr-seed-plan.ts), not this
+ * module's.
+ */
+export declare function extractTopLevelIdentifiers(bladeExpr: string): string[];
+/**
+ * Find the `children` prop's `jsx-children` payload. Narrowed via the
+ * AttrValue `kind` discriminator so adapter code stays type-safe if the IR
+ * shape evolves.
+ */
+export declare function resolveJsxChildrenProp(props: readonly IRProp[]): IRNode[];
+/**
+ * Collect the component's root scope element node(s) — the elements that
+ * become the rendered root and so carry `data-key` for a keyed loop item. A
+ * plain element root is itself; an `if-statement` (early-return) root
+ * contributes the top element of each branch, since exactly one renders at
+ * runtime. (#1297)
+ */
+export declare function collectRootScopeNodes(node: IRNode): Set<IRNode>;
+//# sourceMappingURL=ir-scope.d.ts.map

package/dist/adapter/lib/ir-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-scope.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/ir-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAA6B,MAAM,iBAAiB,CAAA;AAEhF;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAUtE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAKzE;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAiB/D"}

package/dist/adapter/lib/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared type aliases for the Blade template adapter.
+ *
+ * Ported from `packages/adapter-jinja/src/adapter/lib/types.ts`: pure type
+ * declarations — no runtime behaviour — so the extracted emit modules and
+ * the main adapter share one definition rather than re-declaring the
+ * render context / options shape.
+ */
+/** A template-primitive spec: expected call arity + the emit fn. */
+export interface PrimitiveSpec {
+    arity: number;
+    emit: (args: string[]) => string;
+}
+/**
+ * Blade adapter's IRNode render context. Like the Jinja adapter, Blade's
+ * lowering doesn't consume any render-position flags, so the Ctx is empty.
+ * Kept as a named alias so future flags can extend it without changing the
+ * `IRNodeEmitter` interface.
+ */
+export type BladeRenderCtx = Record<string, never>;
+export interface BladeAdapterOptions {
+    /** Base path for client JS files (default: '/static/components/') */
+    clientJsBasePath?: string;
+    /** Path to barefoot.js runtime (default: '/static/components/barefoot.js') */
+    barefootJsPath?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/adapter/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,oEAAoE;AACpE,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CACjC;AAED;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;AAElD,MAAM,WAAW,mBAAmB;IAClC,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAEzB,8EAA8E;IAC9E,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB"}

package/dist/adapter/memo/seed.d.ts

@@ -0,0 +1,84 @@
+/**
+ * In-template memo / context seeding for the Blade template adapter.
+ *
+ * Ported from `packages/adapter-twig/src/adapter/memo/seed.ts`. Free
+ * functions taking a `BladeMemoContext` (built by the adapter's `memoCtx`
+ * getter) so the cluster depends only on the recursive expression entry, not
+ * the whole adapter class. These emit the `@php($x = ...)` statements that
+ * let the body's bare `$x` resolve to a derived signal/memo value or an
+ * active context value at SSR time.
+ *
+ * One deliberate behavioural IMPROVEMENT over the Kolon port, carried
+ * through from the Twig/Jinja ports unchanged: Kolon's `my` declares a NEW
+ * lexical, so `: my $x = … $x …;` reads the not-yet-assigned lexical on its
+ * own right-hand side — broken. Blade's `@php($x = ...)` compiles to a
+ * plain PHP assignment statement — PHP has function-level (not block-level)
+ * scope, and the view-rendering method already `extract()`ed the incoming
+ * template vars into real PHP variables before this statement runs, so
+ * `@php($x = $x + 1)` simply reads-then-reassigns the SAME `$x` — no
+ * shadowing hazard (verified empirically:
+ * `$factory->make('t', ['x' => 5])->render()` over a template whose body is
+ * `@php($x = $x + 1)\n{{ $x }}` → `"6"`, not an error or a stale `5` — same
+ * behaviour Twig/Jinja exhibit). This adapter therefore seeds a same-name
+ * signal/memo too, which is strictly more correct — the seed then
+ * re-derives from the already-bound prop instead of leaving the render var
+ * on its static (possibly per-callsite-wrong) default. No self-ref guard is
+ * ported for this reason (same as the Twig port's divergence 8).
+ */
+import { type ComponentIR, type ContextConsumer } from '@barefootjs/jsx';
+import type { BladeMemoContext } from '../emit-context.ts';
+/** Blade/PHP literal for a context-consumer's `createContext` default. */
+export declare function contextDefaultBlade(c: ContextConsumer): string;
+/**
+ * Emit one `@php($local = $bf->use_context(...))` statement per context
+ * consumer so the body's bare `$local` resolves to the active provider
+ * value (or the `createContext` default). (#1297)
+ */
+export declare function generateContextConsumerSeed(ir: ComponentIR): string;
+/**
+ * Emit `@php($name = <blade>)` statements for every `derived` step of the
+ * backend-neutral SSR seed plan — the scope/availability/ordering analysis
+ * lives in `computeSsrSeedPlan` (packages/jsx/src/ssr-seed-plan.ts); this
+ * only lowers each step's expression to Blade and applies the
+ * backend-specific emit guards: skip an empty lowering, and skip a lowering
+ * that references no top-level identifier at all (a constant init/body —
+ * e.g. a `derived` step with empty `frees` — keeps the existing static
+ * ssr-defaults seed instead). Unlike the Kolon port there is no self-ref
+ * guard — see the file header. `env-reader` and `opaque` steps emit nothing
+ * (the runtime supplies the reader, or the adapter's ssr-defaults path
+ * already covers it). (#1297, #2075)
+ *
+ * `convertExpressionToBlade` can still fail DEEPER than the plan's
+ * structural `isSupported` pre-check — e.g. a `.filter(predicate)` whose
+ * predicate isn't evaluator-serializable has NO lambda fallback on this
+ * adapter (`expr/emitters.ts`'s file header, divergence 9: unlike Kolon/Perl,
+ * Blade has no lambda-expression form), so the lowering records a HARD
+ * BF101 as a side effect rather than degrading. That's correct for every
+ * OTHER `convertExpressionToBlade` call site (which commit to using the
+ * lowered text), but wrong here: this is a SPECULATIVE "recompute the memo
+ * in-template, else keep the static ssrDefault seed" attempt, so a deeper
+ * refusal must degrade silently, not fail the whole component compile.
+ * Snapshot the diagnostic list and roll back any errors appended during each
+ * step's attempt before moving on.
+ *
+ * A second, related divergence opens up: a predicate referencing a SIBLING
+ * getter (`props.items.filter((p) => !tag() || …)`, `tag` a sibling memo)
+ * contains a zero-arg CALL node (`tag()`), which the evaluator's pure-
+ * expression surface refuses (`toEvalNode`'s `call` arm only allows a
+ * builtin callee, e.g. `Math.floor`) — with no lambda fallback to fall back
+ * to, the whole predicate would refuse. Kolon/Perl never hit this: their
+ * lambda form closes over the sibling's ALREADY-SEEDED lexical directly,
+ * without going through the evaluator at all. Go hits the identical gap (it
+ * also has no closures at SSR-constructor time) and fixes it the same way
+ * its `memo/memo-compute.ts` (`matchFilterArmMemo`) does:
+ * `materializeGetterCalls` rewrites a getter call into a bare identifier
+ * BEFORE serialization, so the evaluator captures it as a free-var read from
+ * `base_env` instead of an unsupported call node — and that free var then
+ * resolves against the sibling's own `@php($x = ...)` line, which (being an
+ * EARLIER step per the plan's ordering guarantee) is always already bound.
+ * `env-reader` names are excluded from the materializable set — the runtime
+ * supplies those via the per-request reader, not a template-var lexical, so
+ * a call to one (`searchParams()`) must stay a real call, not a bare var.
+ */
+export declare function generateDerivedMemoSeed(ctx: BladeMemoContext, ir: ComponentIR): string;
+//# sourceMappingURL=seed.d.ts.map

package/dist/adapter/memo/seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../../../src/adapter/memo/seed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,eAAe,EAIrB,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAI1D,0EAA0E;AAC1E,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,eAAe,GAAG,MAAM,CAM9D;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,CAWnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,gBAAgB,EAAE,EAAE,EAAE,WAAW,GAAG,MAAM,CAsBtF"}

package/dist/adapter/props/prop-classes.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Prop classification for the Blade template adapter.
+ *
+ * Ported from `packages/adapter-jinja/src/adapter/props/prop-classes.ts`.
+ * Pure functions over `ir.metadata` that derive the per-compile prop/name
+ * sets the adapter consults during lowering. No adapter instance state.
+ */
+import type { ComponentIR } from '@barefootjs/jsx';
+/**
+ * Props whose declared TS type is boolean — a bare binding of one
+ * (`data-active={props.isActive}`) must stringify as JS `String(boolean)`
+ * ("true"/"false"), not PHP's `(string) bool` ("1"/"") (#1897, pagination's
+ * data-active).
+ */
+export declare function collectBooleanTypedProps(ir: ComponentIR): Set<string>;
+/**
+ * Bare references to optional, no-default, non-primitive props (e.g.
+ * textarea's `rows`) are `null` when omitted → guarded with
+ * `is defined and is not null` in `emitExpression`. See the
+ * `nullableOptionalProps` field docstring in `blade-adapter.ts`.
+ */
+export declare function collectNullableOptionalProps(ir: ComponentIR): Set<string>;
+/**
+ * String-typed signals and props. A signal is string-typed when its inferred
+ * type is `string` (or, defensively, when its initial value is a bare string
+ * literal); a prop when its annotated type is `string`. In the Mojo adapter
+ * this drives `eq`/`ne` selection for string equality; the Blade emitters
+ * don't consume the distinction — `===`/`!==` ALWAYS route through
+ * `bf.eq`/`bf.neq` regardless of operand type (see
+ * `expr/emitters.ts`'s file header, divergence 4) — so this set is carried
+ * only for parity with the Perl-family adapters.
+ */
+export declare function collectStringValueNames(ir: ComponentIR): Set<string>;
+//# sourceMappingURL=prop-classes.d.ts.map

package/dist/adapter/props/prop-classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop-classes.d.ts","sourceRoot":"","sources":["../../../src/adapter/props/prop-classes.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAGlD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAMrE;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAWzE;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAWpE"}

package/dist/adapter/spread/spread-codegen.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Object-literal / conditional-spread → Blade hash lowering for the Blade
+ * template adapter.
+ *
+ * Ported from `packages/adapter-jinja/src/adapter/spread/spread-codegen.ts`.
+ * Free functions taking a `BladeSpreadContext` (built by the adapter's
+ * `spreadCtx` getter) so the cluster depends on the narrow seam — the
+ * recursive expression entry plus per-compile bookkeeping — rather than the
+ * whole adapter class.
+ *
+ * The conditional-spread / object-literal entries read the IR-carried
+ * structured `ParsedExpr` tree (#2018) instead of re-parsing the source with
+ * `ts.createSourceFile`. The condition and scalar values are threaded
+ * straight into `ctx.convertExpressionToBlade` as its `preParsed` argument,
+ * so no stringify→re-parse round-trip occurs. The `ts.factory` rebuild in
+ * `recordIndexAccessToBlade` only reconstructs the `IDENT[KEY]` node the
+ * shared `parseRecordIndexAccess` parser accepts; no source-text re-parse.
+ *
+ * Twig→Blade divergence: a Twig hash literal `{'k': v}` becomes a PHP array
+ * literal `['k' => v]` (mapping table) — `'key' => value` entries joined by
+ * `, `, wrapped in `[...]`, never `{...}`. Empty hash is `[]`, not `{}`.
+ */
+import type { ParsedExpr } from '@barefootjs/jsx';
+import type { BladeSpreadContext } from '../emit-context.ts';
+/**
+ * Lower a conditional inline-object spread
+ *   `COND ? { 'aria-describedby': describedBy } : {}`
+ * to a Blade inline ternary of PHP arrays
+ *   `($bf->truthy($describedBy) ? ['aria-describedby' => $describedBy] : [])`.
+ * Reads the IR-carried structured `ParsedExpr` tree; both branches must be
+ * object literals; the condition + values route through
+ * `convertExpressionToBlade`. Returns `null` for any other shape so the
+ * caller falls back to its normal lowering.
+ */
+export declare function conditionalSpreadToBlade(ctx: BladeSpreadContext, expr: ParsedExpr | undefined): string | null;
+/**
+ * (#1971) Lower a bare object-literal expression (`{ align: 'start' }`),
+ * carried as the IR's structured `ParsedExpr` tree, to a PHP array via
+ * `objectLiteralToBladeDict`, or null when it isn't a plain object literal.
+ * Used for inline object-literal child props (carousel `opts`).
+ */
+export declare function objectLiteralExprToBladeDict(ctx: BladeSpreadContext, expr: ParsedExpr | undefined): string | null;
+/**
+ * Convert a static object literal into a PHP array-literal string for a
+ * conditional spread. Only static string/identifier keys are allowed; values
+ * resolve via `convertExpressionToBlade` (or the `Record[propKey]` index
+ * lowering). Returns `null` for any computed/spread/dynamic key. Empty
+ * object → `[]`.
+ */
+export declare function objectLiteralToBladeDict(ctx: BladeSpreadContext, obj: Extract<ParsedExpr, {
+    kind: 'object-literal';
+}>): string | null;
+/**
+ * Lower a spread-object VALUE of the form `IDENT[KEY]` (CheckIcon's
+ * `sizeMap[size]`) to an inline indexed PHP array
+ *   `['sm' => 16, 'md' => 20, ...][$size]`.
+ * Reuses the shared structural parse (`parseRecordIndexAccess`) — rebuilding
+ * the `IDENT[KEY]` node from the carried tree via `ts.factory` rather than
+ * re-parsing source text; this wrapper only does the single-quote escaping +
+ * bracket-index emit. PHP indexes an array literal with the SAME bracket
+ * syntax `[...][key]` a JS object index would use (verified empirically —
+ * `php -r 'var_dump(["a"=>1]["a"]);'` → `1`) — no Kolon-style divergence to
+ * steer around here. Unlike Twig's own hash `{…}[key]`, a MISSING key here
+ * would normally raise a PHP warning rather than resolve to `null` — this
+ * call site's caller (`objectLiteralToBladeDict`'s data-table lookup path,
+ * and `blade-adapter.ts`'s `${MAP}[key]` template-literal lowering) always
+ * wraps the result in `?? ''`/`?? null`, which silences an undefined-index
+ * warning exactly like it silences an undefined-variable one (see
+ * `blade-adapter.ts`'s file header, the `??` divergence).
+ */
+export declare function recordIndexAccessToBlade(ctx: BladeSpreadContext, val: ParsedExpr): string | null;
+//# sourceMappingURL=spread-codegen.d.ts.map

package/dist/adapter/spread/spread-codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spread-codegen.d.ts","sourceRoot":"","sources":["../../../src/adapter/spread/spread-codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAG5D;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,kBAAkB,EACvB,IAAI,EAAE,UAAU,GAAG,SAAS,GAC3B,MAAM,GAAG,IAAI,CAgBf;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,kBAAkB,EACvB,IAAI,EAAE,UAAU,GAAG,SAAS,GAC3B,MAAM,GAAG,IAAI,CAGf;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,kBAAkB,EACvB,GAAG,EAAE,OAAO,CAAC,UAAU,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,GACnD,MAAM,GAAG,IAAI,CA0Cf;AAUD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,kBAAkB,EAAE,GAAG,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAuBhG"}

package/dist/adapter/value/parsed-literal.d.ts

@@ -0,0 +1,27 @@
+/**
+ * String-literal value lowering for the Blade template adapter.
+ *
+ * Ported from `packages/adapter-jinja/src/adapter/value/parsed-literal.ts`.
+ * Byte-identical logic (the source-text parsing here is language-agnostic;
+ * only the caller's escaping of the resolved value into a template literal
+ * differs, and that happens at the call site in `blade-adapter.ts`, not
+ * here).
+ */
+import { type TypeInfo } from '@barefootjs/jsx';
+/**
+ * Parse a const initializer's source text. Returns the unescaped string value
+ * when the whole initializer is a single pure string literal — single/double
+ * quoted, or a no-substitution backtick template (no `${}`) — else `null`.
+ * Only such a value can be inlined byte-for-byte; template literals with
+ * interpolation, numbers, objects, and `Record<T,string>` maps are excluded.
+ */
+export declare function parsePureStringLiteral(source: string): string | null;
+/** Whether `s` contains an unescaped occurrence of `ch`. */
+export declare function containsUnescaped(s: string, ch: string): boolean;
+/** Unescape a JS string-literal body's common escape sequences. */
+export declare function unescapeStringLiteralBody(s: string): string;
+/** True when `type` is the `string` primitive. */
+export declare function isStringTypeInfo(type: TypeInfo | undefined): boolean;
+/** True when `initialValue` is a bare string-literal expression. */
+export declare function isBareStringLiteral(initialValue: string | undefined): boolean;
+//# sourceMappingURL=parsed-literal.d.ts.map

package/dist/adapter/value/parsed-literal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsed-literal.d.ts","sourceRoot":"","sources":["../../../src/adapter/value/parsed-literal.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAuB,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAEpE;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAqBpE;AAED,4DAA4D;AAC5D,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAMhE;AAED,mEAAmE;AACnE,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAU3D;AAED,kDAAkD;AAClD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,OAAO,CAEpE;AAED,oEAAoE;AACpE,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAI7E"}

package/dist/build.d.ts

@@ -0,0 +1,28 @@
+import type { BuildOptions } from '@barefootjs/jsx';
+import { BladeAdapter } from './adapter/index.ts';
+import type { BladeAdapterOptions } from './adapter/index.ts';
+export interface BladeBuildOptions extends BuildOptions {
+    /** Adapter-specific options passed to BladeAdapter */
+    adapterOptions?: BladeAdapterOptions;
+}
+/**
+ * Create a BarefootBuildConfig for Blade (PHP) template projects.
+ *
+ * Uses structural typing — does not import BarefootBuildConfig to avoid a
+ * circular dependency between @barefootjs/blade and @barefootjs/cli.
+ */
+export declare function createConfig(options?: BladeBuildOptions): {
+    adapter: BladeAdapter;
+    paths: import("@barefootjs/jsx").BarefootPaths | undefined;
+    components: string[] | undefined;
+    outDir: string | undefined;
+    minify: boolean | undefined;
+    contentHash: boolean | undefined;
+    externals: Record<string, import("@barefootjs/jsx").ExternalSpec> | undefined;
+    externalsBasePath: string | undefined;
+    bundleEntries: import("@barefootjs/jsx").BundleEntry[] | undefined;
+    localImportPrefixes: string[] | undefined;
+    outputLayout: import("@barefootjs/jsx").OutputLayout;
+    postBuild: ((ctx: import("@barefootjs/jsx").PostBuildContext) => Promise<void> | void) | undefined;
+};
+//# sourceMappingURL=build.d.ts.map

package/dist/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAE7D,MAAM,WAAW,iBAAkB,SAAQ,YAAY;IACrD,sDAAsD;IACtD,cAAc,CAAC,EAAE,mBAAmB,CAAA;CACrC;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,iBAAsB;IAExD,OAAO;IACP,KAAK;IACL,UAAU;IACV,MAAM;IACN,MAAM;IACN,WAAW;IACX,SAAS;IACT,iBAAiB;IACjB,aAAa;IACb,mBAAmB;IACnB,YAAY;IAKZ,SAAS;EAEZ"}