@barefootjs/jinja 0.1.0

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

@@ -0,0 +1,394 @@
+/**
+ * BarefootJS Jinja2 Template Adapter
+ *
+ * Generates Jinja2 template files (.jinja) from BarefootJS IR.
+ *
+ * Near-mechanical port of the Text::Xslate (Kolon) adapter
+ * (packages/adapter-xslate/src/adapter/xslate-adapter.ts), itself a
+ * near-mechanical port of the Mojolicious EP adapter, from Kolon syntax to
+ * Jinja2 syntax. The expression-lowering PIPELINE (JS → scalar values /
+ * `bf.helper(...)` calls) is shared in spirit with the Xslate adapter; the
+ * surrounding template syntax differs:
+ *
+ *   Kolon `<: EXPR :>`                → Jinja `{{ EXPR }}`                (HTML-escaped)
+ *   Kolon `<: EXPR | mark_raw :>`     → Jinja `{{ EXPR | safe }}`         (raw)
+ *   Kolon `$bf.method(args)`          → Jinja `bf.method(args)`
+ *   Kolon `$name`                     → Jinja `name`
+ *   Kolon `: if (C) { A : } else { B : }` → Jinja `{% if C %}A{% else %}B{% endif %}` (`elsif` → `{% elif %}`)
+ *   Kolon `: for $arr -> $item { … : }`   → Jinja `{% for item in arr %}…{% endfor %}`
+ *   Kolon `: my $x = e;`              → Jinja `{% set x = e %}`
+ *   Kolon `{ k => v }` hashref        → Jinja `{'k': v}` dict literal (ALWAYS quoted key — see `lib/jinja-naming.ts`)
+ *   Kolon `~` concat                  → Jinja `~` concat
+ *   Kolon `//` defined-or             → `(l if (l is defined and l is not none) else r)` inline (Jinja has no `//`; the `is defined` guard also treats a context var that was never seeded — Jinja's `ChainableUndefined` — as nullish, matching JS `??`'s null-OR-undefined check — see `expr/emitters.ts`'s `logical` for the full rationale)
+ *   Kolon macro children capture      → Jinja `{% set NAME %}…{% endset %}` set-block (see "Children capture" below)
+ *
+ * The render `jinja2.Environment` this adapter's output assumes:
+ * `autoescape=True`, `undefined=ChainableUndefined`, `FileSystemLoader`,
+ * PLUS **`trim_blocks=True, lstrip_blocks=True`** — required because this
+ * adapter places `{% … %}` control tags on their own source line (mirroring
+ * Kolon's line-statement `:` mode, which consumes its own line for free);
+ * without `trim_blocks`/`lstrip_blocks` every such line would leak a stray
+ * newline/indentation into the rendered HTML. Templates are named
+ * `<snake_case_component>.jinja` (same convention as Xslate's `.tx` files).
+ *
+ * Divergences beyond the syntax table above (all uniform, not per-fixture —
+ * see the individual definition sites for the full rationale):
+ *
+ *   1. **JS truthiness** (`boolean-result.ts`, `expr/emitters.ts`'s
+ *      `truthyTest`, this file's `convertConditionToJinja`). Python's `[]` /
+ *      `{}` are falsy; JS's are truthy. Perl doesn't have this problem (a
+ *      Perl reference is always true), so Kolon needed no truthy-routing
+ *      layer. Every condition-TEST position (an `{% if %}` / `{% elif %}`
+ *      test, a ternary test, the left operand of `&&`/`||`) routes through
+ *      `bf.truthy(...)` unless it is structurally already boolean-shaped.
+ *   2. **Stringification** (`bf.string`, applied at every text/attribute
+ *      interpolation position). Perl's default scalar stringification is
+ *      close enough to JS's `String(x)` that Kolon only special-cases
+ *      explicit `String()` calls and boolean-typed values (routed to
+ *      `bf.bool_str`). Python's default `str()` diverges further —
+ *      `str(True)` == `"True"`, `str(1.0)` == `"1.0"`, `str(None)` ==
+ *      `"None"`, and Jinja's `~` concatenation operator calls `str()` on
+ *      each operand internally — so this port explicitly routes EVERY
+ *      text/attribute-position value (not already boolean-routed) through
+ *      `bf.string(...)` before it reaches Jinja's own escaping/concat
+ *      machinery. Verified empirically (`'a' ~ true ~ none` → `"aTrueNone"`
+ *      under plain Jinja) — the reason this wrapping is mandatory, not
+ *      cosmetic.
+ *   3. **No Jinja lambda** (`expr/emitters.ts` header, divergence 2). Kolon's
+ *      `-> $x { … }` lambda — the Xslate top-level emitter's fallback when a
+ *      predicate callback can't be serialized to the runtime evaluator's
+ *      JSON form — has no Jinja equivalent. This adapter uses ONE mechanism
+ *      for every higher-order callback (the evaluator-JSON `*_eval`
+ *      payload); an unserializable predicate surfaces `BF101` instead of a
+ *      lambda fallback. `.sort`'s non-lambda STRUCTURED fallback
+ *      (`bf.sort` with a `{keys: […]}` descriptor) is unaffected and ports
+ *      unchanged.
+ *   4. **Children/fallback capture via `{% set %}...{% endset %}`, never a
+ *      macro.** Every Kolon macro-capture site in the ported adapter
+ *      (`renderComponent`'s children forward, `renderAsync`'s fallback) is
+ *      invoked immediately, in place, with zero arguments — never reused
+ *      elsewhere or invoked lazily with different arguments. Jinja's
+ *      set-block (`{% set NAME %}…{% endset %}`) captures exactly that
+ *      shape as a `Markup` string (under `autoescape=True`) with no macro
+ *      indirection needed; the captured name is then referenced bare
+ *      (`NAME`, not `NAME()`) everywhere the Kolon port called `NAME()`.
+ *   5. **Reserved-word identifier mangling** (`lib/jinja-naming.ts`). Every
+ *      bare Jinja variable reference / `{% set %}` target is passed through
+ *      `jinjaIdent()`; the Python runtime must apply the IDENTICAL mangling
+ *      when it builds the per-render context dict (so a prop literally
+ *      named e.g. `class` is threaded through as context key `'class_'` on
+ *      both sides). Dict-LITERAL keys are a separate, unconditional
+ *      concern — see `jinjaHashKey`'s docstring for why they are always
+ *      quoted (unlike Kolon's bareword-key sugar).
+ *   6. **In-template signal/memo self-reference seeding is NOT skipped**
+ *      (`memo/seed.ts`'s file header) — Jinja's `{% set x = x + 1 %}` safely
+ *      resolves the right-hand `x` from the enclosing scope (verified
+ *      empirically), unlike Kolon's `my`-shadowing hazard, so a same-name
+ *      prop-derived signal/memo IS seeded in-template here (Xslate skips
+ *      it). Strictly more correct, not merely a port artifact.
+ */
+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 { JinjaRenderCtx } from './lib/types.ts';
+export type { JinjaAdapterOptions } from './lib/types.ts';
+import type { JinjaAdapterOptions } from './lib/types.ts';
+export declare class JinjaAdapter extends BaseAdapter implements IRNodeEmitter<JinjaRenderCtx> {
+    name: string;
+    extension: string;
+    templatesPerComponent: boolean;
+    importMapInjection: 'html-snippet';
+    /**
+     * Identifier-path callees the Jinja 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 Jinja dict 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 Jinja emitters don't consume it — Jinja's `==`/`!=`
+     * compare strings and numbers correctly.
+     */
+    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 Undefined.
+     */
+    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 dot 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 Jinja
+     * `is defined and is not none` test so the attribute DROPS rather than
+     * rendering `attr=""` (Hono-style nullish omission, e.g. textarea's
+     * `rows`). The filter excludes destructure-defaulted, rest, and
+     * concrete-primitive props.
+     */
+    private nullableOptionalProps;
+    constructor(options?: JinjaAdapterOptions);
+    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: JinjaRenderCtx, _emit: EmitIRNode<JinjaRenderCtx>): string;
+    emitText(node: IRText): string;
+    emitExpression(node: IRExpression): string;
+    emitConditional(node: IRConditional, _ctx: JinjaRenderCtx, _emit: EmitIRNode<JinjaRenderCtx>): string;
+    emitLoop(node: IRLoop, _ctx: JinjaRenderCtx, _emit: EmitIRNode<JinjaRenderCtx>): string;
+    emitComponent(node: IRComponent, _ctx: JinjaRenderCtx, _emit: EmitIRNode<JinjaRenderCtx>): string;
+    emitFragment(node: IRFragment, _ctx: JinjaRenderCtx, _emit: EmitIRNode<JinjaRenderCtx>): string;
+    emitSlot(node: IRSlot): string;
+    emitIfStatement(node: IRIfStatement, _ctx: JinjaRenderCtx, _emit: EmitIRNode<JinjaRenderCtx>): string;
+    emitProvider(node: IRProvider, _ctx: JinjaRenderCtx, _emit: EmitIRNode<JinjaRenderCtx>): string;
+    /** Lower a `<Ctx.Provider value>` value prop to a Jinja expression. */
+    private providerValueJinja;
+    /**
+     * Lower an object-literal provider value (`value={{ open: () => props.open
+     * ?? false, onOpenChange: … }}`) to a Jinja dict 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 `none`
+     * - 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 dict 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 providerObjectLiteralJinja;
+    emitAsync(node: IRAsync, _ctx: JinjaRenderCtx, _emit: EmitIRNode<JinjaRenderCtx>): 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 (Jinja dict-entry
+     * form). Jinja CANNOT splat a dict into positional args, so every prop is
+     * emitted as a `'key': value` entry that the caller collects into ONE dict
+     * literal passed to `bf.render_child(name, { ... })`.
+     *
+     * `jsx-children` returns empty — children are captured via a Jinja
+     * set-block below, not threaded through the dict entry list.
+     */
+    private readonly componentPropEmitter;
+    /**
+     * A `renderComponent` props dict, built as an ORDERED sequence of
+     * segments so `{...before, ...spread, after: 1}` JSX spread semantics
+     * (later entries win) survive the trip through Jinja, which has no
+     * dict-splat syntax for anything past a SINGLE `**` per `dict(...)`
+     * call. Each `'entries'` segment is a literal Jinja dict `{'k': v, ...}`;
+     * each `'spread'` segment is an arbitrary expression lowered from a
+     * `{...expr}` prop. `combineComponentPropSegments` folds the sequence
+     * into ONE expression via nested `dict(base, **top)` calls (later
+     * segment wins on key conflict, matching `Object.assign`/JSX order).
+     */
+    private componentPropSegmentEntries;
+    /**
+     * Fold ordered prop segments into a single Jinja expression via nested
+     * `dict(base, **top)` calls — CPython's `dict()` builtin raises
+     * `TemplateSyntaxError` on MORE THAN ONE `**` per call, so a flat
+     * `dict(**a, **b, **c)` is not an option; each successive segment wraps
+     * the accumulator as the positional `base` with the new segment
+     * `**`-unpacked on top, later argument wins on key conflict — exactly
+     * like `{...a, ...b}`. A spread segment's expression is wrapped
+     * `(EXPR or {})` before unpacking: Jinja's `ChainableUndefined` lets a
+     * missing bag (e.g. `children.props` when `children` was never passed)
+     * chain through member access without raising, but `**`-unpacking an
+     * `Undefined`/`None` value still fails, so the `or {}` guard normalises
+     * it to an empty dict first (verified against real jinja2 3.1.6).
+     * Empty `'entries'` segments are dropped so a leading/trailing spread
+     * doesn't drag in a needless `dict({}, **...)`. Returns `'{}'` when
+     * every segment is empty (no props at all).
+     */
+    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 (Jinja).
+     */
+    private readonly elementAttrEmitter;
+    /**
+     * Lower a `style={{ … }}` object literal to a CSS string with dynamic values
+     * interpolated as Jinja 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 Jinja expression string for filter
+     * predicates. Wraps the shared ParsedExpr dispatcher with a
+     * `JinjaFilterEmitter` carrying the predicate's loop param and any
+     * block-body local var aliases.
+     */
+    private renderJinjaFilterExpr;
+    private convertTemplateLiteralPartsToJinja;
+    /**
+     * Translate `${EXPR}` interpolations in a static template-part string into
+     * Jinja variable references and concatenate them with the surrounding
+     * literal text. Each interpolated (non-literal) segment routes through
+     * `bf.string(...)` — see the file header, divergence 2.
+     */
+    private substituteJsInterpolationsToJinja;
+    /**
+     * Refuse JS expression shapes that have no idiomatic Jinja 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 JinjaEmitContext`)
+     * 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 convertExpressionToJinja;
+    /**
+     * Convert a JS condition (an `if` / ternary / loop-filter test) to a Jinja
+     * boolean expression, routing through `bf.truthy(...)` unless the
+     * expression is structurally already boolean-shaped. See the file header,
+     * divergence 1.
+     */
+    private convertConditionToJinja;
+    /**
+     * Shared helper: given the ORIGINAL JS expression (or its already-parsed
+     * tree) and its ALREADY-RENDERED Jinja text, wrap the rendered text with
+     * `bf.truthy(...)` unless the expression is structurally boolean-shaped.
+     * Split from `convertConditionToJinja` 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 Jinja for top-level (non-filter)
+     * expressions where identifiers are signals / template vars.
+     */
+    private renderParsedExprToJinja;
+    /** Whether `name` (a signal getter or prop) holds a string value. Carried
+     *  for parity with the Perl-family adapters; the Jinja emitters don't
+     *  consume it (Jinja's `==`/`!=` compare strings and numbers correctly). */
+    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 — unlike Kolon's Perl port — correctly stringifies a real
+     * boolean on its own (see `runtime.js_string`'s bool branch), so
+     * layering `bf.bool_str` on top would run Python 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 Undefined.
+     */
+    private _resolveLiteralConst;
+    private _resolveStaticRecordLiteral;
+    private _resolveModuleStringConst;
+    private _recordExprBF101;
+    /** Internal hook for higher-order: predicate body re-uses the filter emitter. */
+    private _renderJinjaFilterExprPublic;
+}
+export declare const jinjaAdapter: JinjaAdapter;
+//# sourceMappingURL=jinja-adapter.d.ts.map

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

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

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

@@ -0,0 +1,21 @@
+/**
+ * Compile-time constant tables for the Jinja2 template adapter.
+ *
+ * Extracted the way `packages/adapter-xslate/src/adapter/lib/constants.ts` is.
+ */
+import type { PrimitiveSpec } from './types.ts';
+/**
+ * Single source of truth for the Jinja adapter's template-primitive
+ * surface. Each entry pairs the expected arity with the emit function.
+ *
+ * The emit fn returns a Jinja expression (no surrounding `{{ }}`) suitable
+ * for embedding inside an interpolation — `bf.json(val)`, `bf.floor(val)`,
+ * etc. The same primitive names as the Xslate adapter, but invoked as
+ * `bf.NAME(args)` (bare, no `$` sigil) instead of `$bf.NAME(args)`.
+ */
+export declare const JINJA_TEMPLATE_PRIMITIVES: Record<string, PrimitiveSpec>;
+/**
+ * Module-scope `templatePrimitives` map derived once from the spec record.
+ */
+export declare const JINJA_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,50 @@
+/**
+ * IR traversal helpers for the Jinja2 template adapter.
+ *
+ * Ported from `packages/adapter-xslate/src/adapter/lib/ir-scope.ts`.
+ * `resolveJsxChildrenProp` and `collectRootScopeNodes` are byte-identical
+ * (adapter-agnostic IR walks).
+ *
+ * `extractTopLevelIdentifiers` scans the RENDERED template text (rather than
+ * re-deriving free vars from the original JS AST) so it stays exactly in
+ * sync with whatever the emitter actually produced — but Jinja identifiers
+ * have no sigil (unlike Kolon's `$`, which made a trivially safe
+ * `\$([A-Za-z_]\w*)` scan possible): a bare word in the rendered text could
+ * be a genuine context-var reference, a `bf.` runtime-helper method name, a
+ * Jinja grammar keyword emitted by this adapter's own condition/ternary
+ * lowering (`if`/`else`/`is`/`not`/`and`/`or`/`none`/`true`/`false`), or
+ * content inside a single-quoted string literal. This helper makes the scan
+ * sound: it strips quoted string spans first, then matches identifier tokens
+ * NOT immediately preceded by a `.` (excluding dotted property/method names
+ * — the same exclusion the `$` sigil gave Kolon for free, since Kolon's
+ * regex only ever matched right after `$`), then drops the closed set of
+ * tokens this adapter's own codegen can emit that aren't context vars (`bf`
+ * and the Jinja keywords above). `memo/seed.ts` uses it to detect a
+ * constant lowering (no top-level identifier at all) that should keep the
+ * static ssr-defaults seed instead of an in-template `{% set %}`; scope
+ * AVAILABILITY itself is now the shared `computeSsrSeedPlan`'s job
+ * (packages/jsx/src/ssr-seed-plan.ts), not this module's (#2075).
+ */
+import type { IRNode, IRProp } from '@barefootjs/jsx';
+/**
+ * Extract the set of "top-level identifier" tokens from a rendered Jinja
+ * expression: bare words, excluding quoted-string content, dotted
+ * property/method names, and this adapter's own non-var keyword vocabulary.
+ * See the file header for why this replaces a direct `\w+` scan.
+ */
+export declare function extractTopLevelIdentifiers(jinjaExpr: 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;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAA6B,MAAM,iBAAiB,CAAA;AAYhF;;;;;GAKG;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/jinja-naming.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Jinja2/Python identifier and dict-key conventions for the Jinja adapter.
+ *
+ * Pure helpers, ported from the Kolon equivalent
+ * (`packages/adapter-xslate/src/adapter/lib/kolon-naming.ts`) but adjusted for
+ * two real syntax divergences between Kolon and Jinja2:
+ *
+ * 1. **Dict-literal keys are always quoted.** Kolon's hashref fat-comma
+ *    (`key => value`) auto-quotes a bareword key, so `kolonHashKey` only
+ *    quotes a non-identifier-safe name (`'data-slot'`). A Jinja/Python dict
+ *    LITERAL has no such bareword-key sugar — `{key: value}` means "look up
+ *    the *variable* `key` and use its value as the key", not the string
+ *    `"key"`. `jinjaHashKey` therefore ALWAYS emits a quoted string literal,
+ *    identifier-safe or not — the one place this port is NOT a bare 1:1
+ *    syntax substitution, because treating it as one would silently change
+ *    dict keys into undefined-variable lookups.
+ * 2. **Reserved-word identifier mangling.** Verified empirically against
+ *    Jinja 3.1 that most Python keywords (`class`, `import`, `for`, …) parse
+ *    fine as bare Jinja variable / loop-target names — Jinja compiles every
+ *    user template name to an internally-prefixed Python local (`l_0_…`), so
+ *    the template layer itself mostly sidesteps Python's own reserved-word
+ *    rules. The genuinely Jinja-reserved bare words are `not` / `and` / `or`
+ *    / `in` / `is` / `if` / `else` (grammar keywords) plus the three
+ *    constants `true` / `false` / `none` (rejected specifically as
+ *    assignment targets). Per the adapter plan, `jinjaIdent` mangles the
+ *    FULL Python reserved-word list (a conservative superset of what Jinja's
+ *    grammar strictly requires) with a trailing-underscore suffix, trivial
+ *    and easy to keep in lock-step with the Python runtime's identical rule
+ *    (`barefootjs.runtime.jinja_ident`) — the runtime applies the SAME
+ *    mangling when it builds the per-render context dict, so a prop/signal
+ *    named e.g. `class` is threaded through as context key `'class_'` on
+ *    both sides.
+ */
+import type { LoopBindingPathSegment } from '@barefootjs/jsx';
+/**
+ * Escape a string for a Jinja/Python single-quoted literal: backslash first
+ * (so it doesn't double-escape the quote we add next), then the quote.
+ * Python string-literal escaping treats `\\` / `\'` identically to Perl's,
+ * so this is byte-identical to `escapeKolonSingleQuoted`.
+ */
+export declare function escapeJinjaSingleQuoted(s: string): string;
+/**
+ * Quote a dict-literal KEY for Jinja. UNLIKE Kolon's `kolonHashKey`, this
+ * always quotes — see the file header for why a bareword key would silently
+ * become a variable lookup instead of a string key.
+ */
+export declare function jinjaHashKey(name: string): string;
+/**
+ * Mangle a JS identifier (prop name, signal getter, loop param, …) into a
+ * Jinja-safe variable name: reserved words get a trailing `_` suffix,
+ * everything else passes through unchanged. Applied at every point the
+ * adapter emits a bare Jinja variable reference or `{% set %}` target —
+ * mirrors Kolon's `$name` sigil giving those references collision immunity
+ * for free; Jinja has no sigil, so the adapter mangles instead.
+ */
+export declare function jinjaIdent(name: string): string;
+/**
+ * Build a native Jinja accessor expression from a `.map()` destructure
+ * binding's structured {@link LoopBindingPathSegment} path (#2087 Phase B) —
+ * the per-adapter counterpart to the JS accessor suffix carried in
+ * `LoopParamBinding.path`. Walks `segments` (never string-parses `path` —
+ * repo rule) appending, per step:
+ *
+ *   - `{ kind: 'index', index }` → `[N]` (a Python list index — same postfix
+ *     Jinja uses for dict-key lookup, so this is unambiguous either way).
+ *   - `{ kind: 'field', key, isIdent: true }` → `.key` (bare attribute
+ *     access — Jinja resolves it against a dict transparently).
+ *   - `{ kind: 'field', key, isIdent: false }` → `[<quoted key>]` (e.g. a
+ *     `'data-priority'` sibling key can't be a bare Jinja attribute, same
+ *     reasoning as `jinjaHashKey` on dict-literal keys).
+ *
+ * `base` is the already-`jinjaIdent`-mangled loop variable (or a parent
+ * accessor expression when called recursively); an empty `segments` array
+ * (a rest binding sitting at the loop root) returns `base` unchanged.
+ */
+export declare function jinjaAccessorFromSegments(base: string, segments: readonly LoopBindingPathSegment[]): string;
+//# sourceMappingURL=jinja-naming.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jinja-naming.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/jinja-naming.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAA;AAE7D;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAcD;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,SAAS,sBAAsB,EAAE,GAC1C,MAAM,CAYR"}

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

@@ -0,0 +1,27 @@
+/**
+ * Shared type aliases for the Jinja2 template adapter.
+ *
+ * Extracted the way `packages/adapter-xslate/src/adapter/lib/types.ts` is:
+ * 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;
+}
+/**
+ * Jinja adapter's IRNode render context. Like the Xslate adapter, Jinja'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 JinjaRenderCtx = Record<string, never>;
+export interface JinjaAdapterOptions {
+    /** 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"}