@barefootjs/rust 0.1.0

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

@@ -0,0 +1,421 @@
+/**
+ * BarefootJS minijinja (Rust) Template Adapter
+ *
+ * Generates Jinja2-compatible template files (.j2) from BarefootJS IR,
+ * rendered at conformance-test / runtime by the `minijinja` Rust crate
+ * (`packages/adapter-rust/runtime/`) instead of Python's `jinja2` package.
+ *
+ * Near-verbatim port of the Jinja2 adapter
+ * (packages/adapter-jinja/src/adapter/jinja-adapter.ts), itself a
+ * near-mechanical port of the Text::Xslate (Kolon) adapter
+ * (packages/adapter-xslate/src/adapter/xslate-adapter.ts). The EMITTED
+ * TEMPLATE SYNTAX IS IDENTICAL to adapter-jinja's output — minijinja 2.21 is
+ * Jinja2-compatible for everything this adapter emits (verified by an
+ * orchestrator spike; see the Environment contract below). Only identity
+ * fields differ (`MinijinjaAdapter`, `name = 'minijinja'`, `extension =
+ * '.j2'`) plus the render engine that interprets the syntax at request time.
+ * The syntax table below is therefore inherited unchanged from the Jinja2
+ * adapter's own header, which in turn documents its lineage from Kolon:
+ *
+ *   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/minijinja-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`/minijinja's `UndefinedBehavior::Chainable` — 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 `minijinja::Environment` this adapter's output assumes (constructed in
+ * the Rust runtime's `backend_minijinja.rs`, verified by the orchestrator
+ * spike against minijinja 2.21.0 — see that crate's module docs for the
+ * full verification notes):
+ *
+ *   env.set_loader(minijinja::path_loader(templates_dir));       // .j2 files
+ *   env.set_undefined_behavior(UndefinedBehavior::Chainable);    // == Jinja2's ChainableUndefined; `missing.deep` renders '' — verified
+ *   env.set_trim_blocks(true);
+ *   env.set_lstrip_blocks(true);
+ *   env.set_auto_escape_callback(|_| AutoEscape::Html);          // REQUIRED: .j2 is not auto-escaped by default in minijinja
+ *   env.set_formatter(<custom formatter>);                       // MarkupSafe-compatible &#39; (not minijinja's default &#x27;), JS-shaped number formatting via format_js_number as a fallback, true/false for bools, undefined/none print nothing
+ *
+ * `trim_blocks`/`lstrip_blocks` are 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
+ * them every such line would leak a stray newline/indentation into the
+ * rendered HTML. Templates are named `<snake_case_component>.j2` (same
+ * convention as adapter-jinja's `.jinja` files and 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. This routing is retained unchanged for the minijinja port —
+ *      the Rust runtime's own default `Display` formatting for a `Value`
+ *      differs from CPython jinja2's `str()` in its own ways (float
+ *      trailing-zero formatting in particular), so `bf.string(...)` stays
+ *      the primary, uniform mechanism; the custom formatter's
+ *      `format_js_number` (see the Environment contract above) is only a
+ *      fallback for values that reach the formatter unrouted.
+ *   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 safe HTML value (Python jinja2's `Markup`; minijinja's
+ *      `Value::from_safe_string`, under the Environment's HTML
+ *      auto-escape callback) 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/minijinja-naming.ts`). Every
+ *      bare Jinja variable reference / `{% set %}` target is passed through
+ *      `minijinjaIdent()`; the Rust runtime must apply the IDENTICAL mangling
+ *      (`mangle_ident` in `render_named`) when it builds the per-render
+ *      context (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 `minijinjaHashKey`'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 { MinijinjaAdapterOptions } from './lib/types.ts';
+import type { MinijinjaAdapterOptions } from './lib/types.ts';
+export declare class MinijinjaAdapter 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?: MinijinjaAdapterOptions);
+    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 — matching the CPython Jinja2 adapter's
+     * emitted syntax exactly (though minijinja itself tolerates more than
+     * one `**` per call, this adapter emits the SAME single-`**`-per-call
+     * nested form so the two engines stay syntax-identical): 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: minijinja's
+     * `UndefinedBehavior::Chainable` 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 needs a concrete dict, so the `or {}` guard normalises it
+     * first (verified against the real minijinja crate v2 `bf-render`
+     * binary). 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 minijinjaAdapter: MinijinjaAdapter;
+//# sourceMappingURL=minijinja-adapter.d.ts.map

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

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

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

@@ -0,0 +1,33 @@
+/**
+ * Prop classification for the minijinja template adapter.
+ *
+ * Ported from `packages/adapter-xslate/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 Python's `str(bool)` ("True"/"False") (#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 `None` when omitted → guarded with
+ * `is defined and is not none` in `emitExpression`. See the
+ * `nullableOptionalProps` field docstring in `minijinja-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; neither the Kolon nor
+ * the Jinja emitters consume the distinction (both languages' `==`/`!=`
+ * compare strings and numbers correctly), so this set is carried for parity
+ * with the Perl-family adapters, not because Jinja needs it today.
+ */
+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;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAWpE"}

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

@@ -0,0 +1,63 @@
+/**
+ * Object-literal / conditional-spread → Jinja dict lowering for the
+ * minijinja template adapter.
+ *
+ * Near-verbatim port of
+ * `packages/adapter-jinja/src/adapter/spread/spread-codegen.ts` (itself
+ * ported from `packages/adapter-xslate/src/adapter/spread/spread-codegen.ts`).
+ * Free functions taking a `JinjaSpreadContext` (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.convertExpressionToJinja` as its `preParsed` argument,
+ * so no stringify→re-parse round-trip occurs. The `ts.factory` rebuild in
+ * `recordIndexAccessToJinja` only reconstructs the `IDENT[KEY]` node the
+ * shared `parseRecordIndexAccess` parser accepts; no source-text re-parse.
+ */
+import type { ParsedExpr } from '@barefootjs/jsx';
+import type { JinjaSpreadContext } from '../emit-context.ts';
+/**
+ * Lower a conditional inline-object spread
+ *   `COND ? { 'aria-describedby': describedBy } : {}`
+ * to a Jinja inline ternary of dicts
+ *   `({'aria-describedby': describedBy} if bf.truthy(describedBy) else {})`.
+ * Reads the IR-carried structured `ParsedExpr` tree; both branches must be
+ * object literals; the condition + values route through
+ * `convertExpressionToJinja`. Returns `null` for any other shape so the
+ * caller falls back to its normal lowering.
+ */
+export declare function conditionalSpreadToJinja(ctx: JinjaSpreadContext, expr: ParsedExpr | undefined): string | null;
+/**
+ * (#1971) Lower a bare object-literal expression (`{ align: 'start' }`),
+ * carried as the IR's structured `ParsedExpr` tree, to a Jinja dict via
+ * `objectLiteralToJinjaDict`, or null when it isn't a plain object literal.
+ * Used for inline object-literal child props (carousel `opts`).
+ */
+export declare function objectLiteralExprToJinjaDict(ctx: JinjaSpreadContext, expr: ParsedExpr | undefined): string | null;
+/**
+ * Convert a static object literal into a Jinja dict string for a
+ * conditional spread. Only static string/identifier keys are allowed; values
+ * resolve via `convertExpressionToJinja` (or the `Record[propKey]` index
+ * lowering). Returns `null` for any computed/spread/dynamic key. Empty
+ * object → `{}`.
+ */
+export declare function objectLiteralToJinjaDict(ctx: JinjaSpreadContext, 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 Jinja dict
+ *   `{'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. Jinja indexes a dict literal with the SAME bracket
+ * syntax `{…}[key]` a JS object index would use — no Kolon-style divergence
+ * to steer around here.
+ */
+export declare function recordIndexAccessToJinja(ctx: JinjaSpreadContext, 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;;;;;;;;;;;;;;;;;;;GAmBG;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,CAcf;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;;;;;;;;;;GAUG;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,28 @@
+/**
+ * String-literal value lowering for the minijinja template adapter.
+ *
+ * Ported from `packages/adapter-xslate/src/adapter/value/parsed-literal.ts`.
+ * Pure functions over const-initializer source text and analyzer type info —
+ * no adapter instance state. Byte-identical logic to the Xslate copy (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 `minijinja-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;;;;;;;;;GASG;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,29 @@
+import type { BuildOptions } from '@barefootjs/jsx';
+import { MinijinjaAdapter } from './adapter/index.ts';
+import type { MinijinjaAdapterOptions } from './adapter/index.ts';
+export interface MinijinjaBuildOptions extends BuildOptions {
+    /** Adapter-specific options passed to MinijinjaAdapter */
+    adapterOptions?: MinijinjaAdapterOptions;
+}
+/**
+ * Create a BarefootBuildConfig for minijinja (Jinja2-compatible) template
+ * projects.
+ *
+ * Uses structural typing — does not import BarefootBuildConfig to avoid a
+ * circular dependency between @barefootjs/rust and @barefootjs/cli.
+ */
+export declare function createConfig(options?: MinijinjaBuildOptions): {
+    adapter: MinijinjaAdapter;
+    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,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAA;AAEjE,MAAM,WAAW,qBAAsB,SAAQ,YAAY;IACzD,0DAA0D;IAC1D,cAAc,CAAC,EAAE,uBAAuB,CAAA;CACzC;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,qBAA0B;IAE5D,OAAO;IACP,KAAK;IACL,UAAU;IACV,MAAM;IACN,MAAM;IACN,WAAW;IACX,SAAS;IACT,iBAAiB;IACjB,aAAa;IACb,mBAAmB;IACnB,YAAY;IAKZ,SAAS;EAEZ"}