@barefootjs/rust 0.1.0

package/src/adapter/props/prop-classes.ts

@@ -0,0 +1,65 @@
+/**
+ * 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'
+import { isStringTypeInfo, isBareStringLiteral } from '../value/parsed-literal.ts'
+
+/**
+ * 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 function collectBooleanTypedProps(ir: ComponentIR): Set<string> {
+  return new Set(
+    ir.metadata.propsParams
+      .filter(prop => prop.type?.primitive === 'boolean' || prop.type?.raw === 'boolean')
+      .map(prop => prop.name),
+  )
+}
+
+/**
+ * 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 function collectNullableOptionalProps(ir: ComponentIR): Set<string> {
+  return new Set(
+    ir.metadata.propsParams
+      .filter(
+        p =>
+          p.defaultValue === undefined &&
+          !p.isRest &&
+          p.type?.kind !== 'primitive',
+      )
+      .map(p => p.name),
+  )
+}
+
+/**
+ * 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 function collectStringValueNames(ir: ComponentIR): Set<string> {
+  const names = new Set<string>()
+  for (const s of ir.metadata.signals) {
+    if (isStringTypeInfo(s.type) || isBareStringLiteral(s.initialValue)) {
+      names.add(s.getter)
+    }
+  }
+  for (const p of ir.metadata.propsParams) {
+    if (isStringTypeInfo(p.type)) names.add(p.name)
+  }
+  return names
+}

package/src/adapter/spread/spread-codegen.ts

@@ -0,0 +1,168 @@
+/**
+ * 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 ts from 'typescript'
+import { parseRecordIndexAccess, stringifyParsedExpr } from '@barefootjs/jsx'
+import type { ParsedExpr } from '@barefootjs/jsx'
+
+import type { JinjaSpreadContext } from '../emit-context.ts'
+import { escapeMinijinjaSingleQuoted, minijinjaHashKey, minijinjaIdent } from '../lib/minijinja-naming.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 function conditionalSpreadToJinja(
+  ctx: JinjaSpreadContext,
+  expr: ParsedExpr | undefined,
+): string | null {
+  if (!expr || expr.kind !== 'conditional') return null
+  const whenTrue = expr.consequent
+  const whenFalse = expr.alternate
+  if (whenTrue.kind !== 'object-literal' || whenFalse.kind !== 'object-literal') {
+    return null
+  }
+  // Thread the condition's carried `ParsedExpr` tree straight through as
+  // `preParsed` (#2018) — no stringify→re-parse round-trip.
+  const condJinja = ctx.convertConditionToJinja('', expr.test)
+  const trueJinja = objectLiteralToJinjaDict(ctx, whenTrue)
+  const falseJinja = objectLiteralToJinjaDict(ctx, whenFalse)
+  if (trueJinja === null || falseJinja === null) return null
+  return `(${trueJinja} if ${condJinja} else ${falseJinja})`
+}
+
+/**
+ * (#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 function objectLiteralExprToJinjaDict(
+  ctx: JinjaSpreadContext,
+  expr: ParsedExpr | undefined,
+): string | null {
+  if (!expr || expr.kind !== 'object-literal') return null
+  return objectLiteralToJinjaDict(ctx, expr)
+}
+
+/**
+ * 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 function objectLiteralToJinjaDict(
+  ctx: JinjaSpreadContext,
+  obj: Extract<ParsedExpr, { kind: 'object-literal' }>,
+): string | null {
+  const entries: string[] = []
+  for (const prop of obj.properties) {
+    // Shorthand `{ a }` was a `ShorthandPropertyAssignment` (not a
+    // `PropertyAssignment`), so the former parser rejected it — keep refusing.
+    if (prop.shorthand) return null
+    // A numeric key (`{ 1: x }`) was rejected by the former parser (only
+    // identifier / string-literal names were accepted); `keyKind`
+    // distinguishes it from a same-text string `'1'` key.
+    if (prop.keyKind === 'numeric') return null
+    const key = prop.key
+    const val = prop.value
+    const indexed = recordIndexAccessToJinja(ctx, val)
+    if (
+      indexed === null &&
+      val.kind === 'index-access' &&
+      !isLiteralIndex(val.index)
+    ) {
+      // Variable-index record access (`sizeMap[size]`) the static-inline
+      // path couldn't resolve (non-scalar value / non-const receiver).
+      // Record BF101 and bail so the spread surfaces the out-of-shape
+      // diagnostic, matching the Kolon port.
+      ctx.errors.push({
+        code: 'BF101',
+        severity: 'error',
+        message: `Spread object value '${stringifyParsedExpr(val)}' indexes a record map whose values aren't scalar literals — it can't lower to an inline Jinja dict.`,
+        loc: { file: ctx.componentName + '.tsx', start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+        suggestion: {
+          message: 'Index a record whose values are number/string literals, or move the spread into a \'use client\' component so hydration computes it.',
+        },
+      })
+      return null
+    }
+    const valJinja =
+      indexed !== null
+        ? indexed
+        // Thread the carried `val` tree straight through as `preParsed`
+        // (#2018) — no stringify→re-parse round-trip.
+        : ctx.convertExpressionToJinja('', val)
+    entries.push(`${minijinjaHashKey(key)}: ${valJinja}`)
+  }
+  return entries.length === 0 ? '{}' : `{${entries.join(', ')}}`
+}
+
+/** True when a parsed index is a numeric or string literal (`arr[0]`, `m['k']`). */
+function isLiteralIndex(index: ParsedExpr): boolean {
+  return (
+    index.kind === 'literal' &&
+    (index.literalType === 'number' || index.literalType === 'string')
+  )
+}
+
+/**
+ * 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 function recordIndexAccessToJinja(ctx: JinjaSpreadContext, val: ParsedExpr): string | null {
+  // The only shape `parseRecordIndexAccess` accepts is `IDENT[KEY]` with
+  // identifier object and index, so rebuild exactly that node from the
+  // carried tree via `ts.factory` — no source-text re-parse.
+  if (
+    val.kind !== 'index-access' ||
+    val.object.kind !== 'identifier' ||
+    val.index.kind !== 'identifier'
+  ) {
+    return null
+  }
+  const tsVal = ts.factory.createElementAccessExpression(
+    ts.factory.createIdentifier(val.object.name),
+    ts.factory.createIdentifier(val.index.name),
+  )
+  const parsed = parseRecordIndexAccess(tsVal, ctx.localConstants ?? [], ctx.propsParams)
+  if (!parsed) return null
+  const entries = parsed.entries.map(e => {
+    const mapVal =
+      e.value.kind === 'number' ? e.value.text : `'${escapeMinijinjaSingleQuoted(e.value.text)}'`
+    return `${minijinjaHashKey(e.key)}: ${mapVal}`
+  })
+  return `{${entries.join(', ')}}[${minijinjaIdent(parsed.indexPropName)}]`
+}

package/src/adapter/value/parsed-literal.ts

@@ -0,0 +1,76 @@
+/**
+ * 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 { evalStringArrayJoin, 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 function parsePureStringLiteral(source: string): string | null {
+  let s = source.trim()
+  // Peel a single layer of wrapping parens.
+  while (s.startsWith('(') && s.endsWith(')')) s = s.slice(1, -1).trim()
+  const quote = s[0]
+  if ((quote === "'" || quote === '"') && s[s.length - 1] === quote) {
+    const body = s.slice(1, -1)
+    // Reject if an unescaped matching quote appears inside (not a single
+    // literal then).
+    if (containsUnescaped(body, quote)) return null
+    return unescapeStringLiteralBody(body)
+  }
+  if (quote === '`' && s[s.length - 1] === '`') {
+    const body = s.slice(1, -1)
+    if (body.includes('${')) return null
+    if (containsUnescaped(body, '`')) return null
+    return unescapeStringLiteralBody(body)
+  }
+  // `[<literals>].join(' ')` module consts (e.g. Switch's `trackStateClasses`)
+  // → inline the flattened string byte-for-byte. See `evalStringArrayJoin`.
+  return evalStringArrayJoin(source)
+}
+
+/** Whether `s` contains an unescaped occurrence of `ch`. */
+export function containsUnescaped(s: string, ch: string): boolean {
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '\\') { i++; continue }
+    if (s[i] === ch) return true
+  }
+  return false
+}
+
+/** Unescape a JS string-literal body's common escape sequences. */
+export function unescapeStringLiteralBody(s: string): string {
+  return s.replace(/\\(.)/g, (_, c) => {
+    switch (c) {
+      case 'n': return '\n'
+      case 'r': return '\r'
+      case 't': return '\t'
+      case '0': return '\0'
+      default: return c
+    }
+  })
+}
+
+/** True when `type` is the `string` primitive. */
+export function isStringTypeInfo(type: TypeInfo | undefined): boolean {
+  return type?.kind === 'primitive' && type.primitive === 'string'
+}
+
+/** True when `initialValue` is a bare string-literal expression. */
+export function isBareStringLiteral(initialValue: string | undefined): boolean {
+  if (!initialValue) return false
+  const v = initialValue.trim()
+  return (v.startsWith("'") && v.endsWith("'")) || (v.startsWith('"') && v.endsWith('"'))
+}

package/src/build.ts

@@ -0,0 +1,38 @@
+// minijinja (Rust) build config factory for barefoot.config.ts
+
+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 function createConfig(options: MinijinjaBuildOptions = {}) {
+  return {
+    adapter: new MinijinjaAdapter(options.adapterOptions),
+    paths: options.paths,
+    components: options.components,
+    outDir: options.outDir,
+    minify: options.minify,
+    contentHash: options.contentHash,
+    externals: options.externals,
+    externalsBasePath: options.externalsBasePath,
+    bundleEntries: options.bundleEntries,
+    localImportPrefixes: options.localImportPrefixes,
+    outputLayout: options.outputLayout ?? {
+      templates: 'templates',
+      clientJs: 'client',
+      runtime: 'client',
+    },
+    postBuild: options.postBuild,
+  }
+}

package/src/conformance-pins.ts

@@ -0,0 +1,101 @@
+/**
+ * Per-fixture build-time contracts for shapes the adapter intentionally
+ * refuses to lower. Mirrors adapter-jinja's set (itself mirroring
+ * xslate's) — the lowering gates are shared code paths in the ported
+ * adapter (BF103/BF104 are structural: cross-template child registration
+ * / destructure-loop-param limits that apply identically regardless of
+ * target template language or render engine). Consumed by this package's
+ * own conformance test (as `expectedDiagnostics`) and by `bf compat`
+ * (issue-URL attribution).
+ */
+
+import type { ConformancePins } from '@barefootjs/jsx'
+
+export const conformancePins: ConformancePins = {
+  // Sibling-imported child component in a loop body: emits a
+  // cross-template call needing separate registration. BF103 makes
+  // the requirement loud (same as xslate).
+  'static-array-children': [{ code: 'BF103', severity: 'error' }],
+  // TodoApp / TodoAppSSR import `TodoItem` from a sibling file and
+  // call it inside a keyed `.map`. Same BF103 (imported child in
+  // `.map`) as xslate.
+  'todo-app': [{ code: 'BF103', severity: 'error' }],
+  'todo-app-ssr': [{ code: 'BF103', severity: 'error' }],
+  // The `([emoji, users]) => ...` / `([id, t]) => ...` params in these two
+  // fixtures no longer trip BF104 — the destructure itself now lowers
+  // cleanly to a native `{% set %}` accessor (#2087 Phase B). But both
+  // fixtures' loop array is `entries`, a bare identifier bound to a
+  // function-scope local const with a NON-inlineable initializer
+  // (`Object.entries(props.x ?? {}).filter(...)`) — a pre-existing,
+  // orthogonal limitation this adapter has always had (it only ever
+  // INLINES a local const's value at its use site — numeric/string
+  // literal, or a static-record-literal lookup — never binds one as a
+  // `{% set %}` template local), just never reachable before because the
+  // narrower pre-#2087 gate refused the destructure param first. Left
+  // unhandled it would silently render an EMPTY list (minijinja's
+  // `UndefinedBehavior::Chainable` tolerates iterating an unbound name as
+  // zero iterations) instead of failing loudly, so `renderLoop` in
+  // `minijinja-adapter.ts` now detects this shape and raises BF101
+  // instead — see the "Loop array `<name>` is a local computed value"
+  // diagnostic (mirrors adapter-jinja's identical check). Fixing the
+  // underlying gap (computed-array-from-props as a loop source) is out of
+  // scope for #2087; tracked as a follow-up at
+  // https://github.com/piconic-ai/barefootjs/issues/2087.
+  'static-array-from-props': [
+    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2087' },
+  ],
+  // Both BF103 (imported child) and BF101 (unresolvable computed loop
+  // array, see above) fire.
+  'static-array-from-props-with-component': [
+    { code: 'BF103', severity: 'error' },
+    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2087' },
+  ],
+  // Rest-destructure `.map()` callbacks (#2087 Phase B): every shape now
+  // lowers natively — fixed bindings at any depth/shape via a chained
+  // Jinja accessor built off `LoopParamBinding.segments`
+  // (`minijinjaAccessorFromSegments`), array-rest via the runtime's
+  // `bf.slice`, and object-rest (read via member access OR spread onto an
+  // intrinsic element) via a TRUE residual dict from the new `bf.omit`
+  // runtime helper. No `expectedDiagnostics` pins remain for any of the
+  // `rest-destructure-*-in-map` / `destructure-*-in-map` fixtures — see
+  // `rest-destructure-object-spread-in-map` for the residual-spread case
+  // and `destructure-array-index-in-map` / `destructure-nested-object-in-map`
+  // for the no-rest fixed-binding shapes.
+  // (button/kbd graduated: the site/ui Button/Kbd `<Slot>` `{...props}` /
+  // `{...children.props}` component-spread now lowers via nested
+  // `dict(base, **top)` calls — see `minijinja-adapter.ts`'s
+  // `renderComponent` — instead of refusing with BF101, so these two no
+  // longer need a pin here.)
+  // (`tagged-template-classname` graduated by #2092 — the tag resolves
+  // through the interleave-tag catalogue and desugars to an untagged
+  // template literal, so it lowers like any other className template.)
+  // #2038: a filter predicate whose body contains a NESTED callback call
+  // (`t => !picked().some(p => …)` / `t => picked().find(p => …)`). Jinja
+  // has no inline comprehension-with-nested-callback form usable from the
+  // evaluator-JSON `*_eval` payload mechanism (this adapter's ONLY
+  // higher-order-callback lowering path — see `minijinja-adapter.ts`'s file
+  // header, divergence 3), so the compiler is loud (BF101) instead of
+  // lossy, same as xslate. The `/* @client */` twin
+  // (`filter-nested-callback-predicate-client`) has no pin here: it must
+  // render clean on every adapter, which asserts the suppression contract.
+  // https://github.com/piconic-ai/barefootjs/issues/2038
+  'filter-nested-callback-predicate': [
+    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2038' },
+  ],
+  'filter-nested-find-predicate': [
+    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2038' },
+  ],
+  // NB: TOP-LEVEL `.find` / `.findIndex` / `.findLast` / `.findLastIndex`
+  // (text position) are NOT pinned here — like xslate (unlike mojo, which
+  // refuses them), Jinja lowers them to `bf.find_eval` / `find_index_eval`
+  // / etc. via the same evaluator-JSON mechanism as `.filter` / `.every` /
+  // `.some`, so they render. Only the NESTED-in-a-predicate form above is
+  // refused (#2038).
+  // #2073 follow-up (same as xslate): a function-reference `.map(format)`
+  // callback has no arrow body to serialize — not a CALLBACK_METHODS shape
+  // (`asCallbackMethodCall` requires an arrow argument) — so the shared
+  // `isSupported`'s `UNSUPPORTED_METHODS` gate refuses it with the generic
+  // "Expression not supported" BF101 rather than emitting a broken
+  // template.
+  'array-map-function-reference': [{ code: 'BF101', severity: 'error' }],
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+/**
+ * BarefootJS minijinja (Rust) Template Adapter
+ *
+ * Generates Jinja2-compatible template files (.j2) from BarefootJS IR,
+ * rendered by the `minijinja` Rust crate. Near-verbatim port of
+ * `@barefootjs/jinja` — see `adapter/minijinja-adapter.ts`'s file header for
+ * the full design record.
+ */
+
+export { MinijinjaAdapter, minijinjaAdapter } from './adapter/index.ts'
+export type { MinijinjaAdapterOptions } from './adapter/index.ts'
+export { conformancePins } from './conformance-pins.ts'