@barefootjs/jinja 0.1.0

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

@@ -0,0 +1,81 @@
+/**
+ * In-template memo / context seeding for the Jinja template adapter.
+ *
+ * Ported from `packages/adapter-xslate/src/adapter/memo/seed.ts`. Free
+ * functions taking a `JinjaMemoContext` (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 `{% set 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: Kolon's `my`
+ * declares a NEW lexical, so `: my $x = … $x …;` reads the not-yet-assigned
+ * lexical on its own right-hand side — broken. Xslate therefore skips
+ * in-template seeding for a same-name signal/memo (a `refsSelf` guard in its
+ * `generateDerivedMemoSeed`). Jinja's `{% set %}` has no such shadowing
+ * hazard — `{% set x = x + 1 %}` resolves the right-hand `x` against the
+ * value ALREADY bound in the enclosing scope (verified empirically against
+ * Jinja 3.1: `env.from_string("{% set x = x + 1 %}{{ x }}").render(x=5)` →
+ * `"6"`, not an error or a stale `5`). 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.
+ */
+import { type ComponentIR, type ContextConsumer } from '@barefootjs/jsx';
+import type { JinjaMemoContext } from '../emit-context.ts';
+/** Jinja literal for a context-consumer's `createContext` default. */
+export declare function contextDefaultJinja(c: ContextConsumer): string;
+/**
+ * Emit one `{% set <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 `{% set <name> = <jinja> %}` 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 Jinja 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)
+ *
+ * `convertExpressionToJinja` 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 (divergence 3, `jinja-adapter.ts`'s file header: unlike Kolon/Perl,
+ * Jinja 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 `convertExpressionToJinja` 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 Jinja-only gap divergence 3 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 `{% set %}` 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: JinjaMemoContext, 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;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,eAAe,EAIrB,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAI1D,sEAAsE;AACtE,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,33 @@
+/**
+ * Prop classification for the Jinja2 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 `jinja-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,61 @@
+/**
+ * Object-literal / conditional-spread → Jinja dict lowering for the Jinja
+ * template adapter.
+ *
+ * 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;;;;;;;;;;;;;;;;;GAiBG;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 Jinja2 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 `jinja-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,28 @@
+import type { BuildOptions } from '@barefootjs/jsx';
+import { JinjaAdapter } from './adapter/index.ts';
+import type { JinjaAdapterOptions } from './adapter/index.ts';
+export interface JinjaBuildOptions extends BuildOptions {
+    /** Adapter-specific options passed to JinjaAdapter */
+    adapterOptions?: JinjaAdapterOptions;
+}
+/**
+ * Create a BarefootBuildConfig for Jinja2 template projects.
+ *
+ * Uses structural typing — does not import BarefootBuildConfig to avoid a
+ * circular dependency between @barefootjs/jinja and @barefootjs/cli.
+ */
+export declare function createConfig(options?: JinjaBuildOptions): {
+    adapter: JinjaAdapter;
+    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"}