@barefootjs/xslate 0.33.4 → 0.34.0

package/lib/BarefootJS/Backend/Xslate.pm

@@ -1,5 +1,5 @@
 package BarefootJS::Backend::Xslate;
-our $VERSION = "0.33.3";
+our $VERSION = "0.33.6";
 use strict;
 use warnings;
 use utf8;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/xslate",
-  "version": "0.33.4",
+  "version": "0.34.0",
   "description": "Text::Xslate (Kolon) adapter for BarefootJS — compiles IR to .tx templates and ships the Xslate rendering backend; runs under any PSGI/Plack app",
   "type": "module",
   "main": "./dist/index.js",
@@ -55,7 +55,7 @@
     "directory": "packages/adapter-xslate"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.33.4"
+    "@barefootjs/shared": "0.34.0"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -72,9 +72,9 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.33.4",
-    "@barefootjs/vite": "0.33.4",
-    "@barefootjs/client": "0.33.4",
+    "@barefootjs/jsx": "0.34.0",
+    "@barefootjs/vite": "0.34.0",
+    "@barefootjs/client": "0.34.0",
     "typescript": "^5.0.0",
     "vite": "^6.0.0"
   }

package/src/adapter/emit-context.ts

@@ -18,7 +18,7 @@
  * rather than re-exposing the whole adapter.
  */
 
-import type { ParsedExpr, CompilerError, IRMetadata } from '@barefootjs/jsx'
+import type { ParsedExpr, CompilerError, IRMetadata, LoweringMatcher } from '@barefootjs/jsx'
 
 export interface XslateEmitContext {
   /**
@@ -27,6 +27,17 @@ export interface XslateEmitContext {
    */
   readonly _searchParamsLocals: Set<string>
 
+  /**
+   * Registered lowering-plugin matchers (#2057), bound to this component's
+   * metadata at init. Read by `XslateTopLevelEmitter`'s `lowering` seam
+   * (#2843) so a registered call — the built-in `queryHref`, or any
+   * userland plugin — is recognised no matter where it sits in an
+   * expression tree (a ternary branch, a template-literal interpolation, …),
+   * not only when it's the call the adapter's own top-level conversion
+   * entry point (`convertExpressionToKolon`) is asked to lower directly.
+   */
+  readonly _loweringMatchers: readonly LoweringMatcher[]
+
   /**
    * Inline a module-scope pure string-literal const by name as the resolved
    * literal value, or null when the name is not such a const.

package/src/adapter/expr/emitters.ts

@@ -15,6 +15,8 @@ import { groupBinaryOperand,
   groupObjectLiteralSegments,
   isStringConcatBinary,
   type ParsedExprEmitter,
+  type LoweringEmitter,
+  type LoweringNode,
   type HigherOrderMethod,
   type ArrayMethod,
   type LiteralType,
@@ -25,6 +27,8 @@ import { groupBinaryOperand,
   identifierPath,
   matchSearchParamsMethodCall,
   sortComparatorFromArrow,
+  queryHrefArgs,
+  isValidHelperId,
 } from '@barefootjs/jsx'
 
 import type { XslateEmitContext } from '../emit-context.ts'
@@ -267,6 +271,35 @@ export class XslateTopLevelEmitter implements ParsedExprEmitter {
     this.ctx = ctx
   }
 
+  /**
+   * Registered-lowering seam (#2843): `emitParsedExpr`'s shared `call` case
+   * tries every matcher here BEFORE `call()` itself, so a registered call
+   * (the built-in `queryHref`, or any userland plugin) is recognised no
+   * matter where it sits in the tree. `render` is what used to live inline
+   * in `XslateAdapter.convertExpressionToKolon` before the object-literal
+   * support-gate refusal (`checkSupport`'s `call` arm, now itself
+   * registry-aware) made the pre-gate special case unnecessary.
+   */
+  get lowering(): LoweringEmitter {
+    return {
+      matchers: this.ctx._loweringMatchers,
+      render: (node: LoweringNode, emit: (e: ParsedExpr) => string): string | null => {
+        // `query` guard-list — `queryHref`-shaped.
+        if (node.kind === 'guard-list' && node.helper === 'query') {
+          const qArgs = queryHrefArgs(node, emit)
+          return `$bf.query(${qArgs.join(', ')})`
+        }
+        // Generic `helper-call` (#2069) — a userland `LoweringPlugin`'s
+        // single runtime-helper invocation; `$bf.<helper>(args…)` mirrors
+        // the `query` helper's own naming convention.
+        if (node.kind === 'helper-call' && isValidHelperId(node.helper)) {
+          return `$bf.${node.helper}(${node.args.map(emit).join(', ')})`
+        }
+        return null
+      },
+    }
+  }
+
   identifier(name: string): string {
     // `undefined` / `null` nested inside a larger expression tree —
     // Kolon `nil` (#1897).

package/src/adapter/xslate-adapter.ts

@@ -70,8 +70,6 @@ import {
   lookupStaticRecordLiteral,
   searchParamsLocalNames,
   prepareLoweringMatchers,
-  queryHrefArgs,
-  isValidHelperId,
   sortComparatorFromArrow,
   isLowerableLoopDestructure,
   isDangerousInnerHtmlAttr,
@@ -81,6 +79,7 @@ import {
   resolveStaticLoopSource,
   derivesScopeFromSlot,
   BindingScope,
+  buildImportAliasMap,
 } from '@barefootjs/jsx'
 import { isAriaBooleanAttr, isBooleanResultExpr } from './boolean-result.ts'
 import ts from 'typescript'
@@ -258,6 +257,20 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
    */
   private nullableOptionalProps: Set<string> = new Set()
 
+  /**
+   * Local alias -> declared/exported name for imported components (#2822,
+   * the SSR-side counterpart of #2777's client-JS registry-key fix). A
+   * child referenced under an import alias (`import { Foo as Bar }`,
+   * `<Bar/>`) must build its cross-template call against the child's own
+   * declared name (`Foo`, what `foo.tsx` registers its Kolon partial as) —
+   * never the caller-local binding. Xslate's unresolved-reference case
+   * silently drops the child rather than raising, so this was the worst
+   * variant of the bug class. Built once per compile from
+   * `ir.metadata.imports` via the shared `buildImportAliasMap`
+   * (`@barefootjs/jsx`) and read by `toTemplateName`.
+   */
+  private importAliases: Map<string, string> = new Map()
+
   constructor(options: XslateAdapterOptions = {}) {
     super()
     this.options = {
@@ -287,6 +300,7 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
     this.moduleStringConsts = collectModuleStringConsts(ir.metadata.localConstants)
     this._searchParamsLocals = searchParamsLocalNames(ir.metadata)
     this._loweringMatchers = prepareLoweringMatchers(ir.metadata)
+    this.importAliases = buildImportAliasMap(ir.metadata.imports ?? [])
     this.errors = []
     this.childrenCaptureCounter = 0
 
@@ -1229,8 +1243,14 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
   private presenceVarCounter = 0
 
   private toTemplateName(componentName: string): string {
+    // Resolve an import alias (`import { Foo as Bar }`, `<Bar/>`) back to
+    // the child's own declared name BEFORE snake-casing (#2822) — `Bar`
+    // has no `foo.tsx`-registered partial; only `Foo` does. Xslate's
+    // unresolved-reference case silently drops the child rather than
+    // raising, so this mismatch was the worst variant of the bug class.
+    const declaredName = this.importAliases.get(componentName) ?? componentName
     // Convert PascalCase to snake_case for template naming.
-    return componentName
+    return declaredName
       .replace(/([A-Z])/g, '_$1')
       .toLowerCase()
       .replace(/^_/, '')
@@ -1381,8 +1401,13 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
       {
         const m = this.parseUndefinedAlternateTernary(value.expr)
         if (m) {
-          const cond = this.convertExpressionToKolon(m.condition)
-          const val = this.convertExpressionToKolon(m.consequent)
+          // Pass the PARSED sub-trees through as `preParsed` (#2843 review)
+          // rather than re-parsing `m.condition`/`m.consequent` — those are
+          // `exprToString` debug text, which renders any nested
+          // `object-literal` (e.g. a registered call's params, `queryHref`'s
+          // `{ tag }`) as a non-reparseable `[UNSUPPORTED: …]` placeholder.
+          const cond = this.convertExpressionToKolon('', m.testParsed)
+          const val = this.convertExpressionToKolon('', m.consequentParsed)
           return `\n: if (${cond}) {\n${name}="<: ${val} :>"\n: }\n`
         }
       }
@@ -1637,7 +1662,7 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
     const hasTaggedTemplate = /[A-Za-z_$][\w$]*\s*`/.test(probe)
     if (!startsAsObjectLiteral && !hasTaggedTemplate) return false
     const parsed = parseExpression(expr.trim())
-    const support = isSupported(parsed)
+    const support = isSupported(parsed, { loweringMatchers: this._loweringMatchers })
     if (parsed.kind !== 'unsupported' && support.supported) return false
     const reason = support.reason ?? (parsed.kind === 'unsupported' ? parsed.reason : undefined)
     const reasonLine = reason ? `\n${reason}` : ''
@@ -1664,6 +1689,7 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
   private get emitCtx(): XslateEmitContext {
     return {
       _searchParamsLocals: this._searchParamsLocals,
+      _loweringMatchers: this._loweringMatchers,
       _resolveModuleStringConst: (name) => this._resolveModuleStringConst(name),
       _resolveLiteralConst: (name) => this._resolveLiteralConst(name),
       _resolveStaticRecordLiteral: (o, k) => this._resolveStaticRecordLiteral(o, k),
@@ -1715,42 +1741,22 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
       parsed = parseExpression(trimmed)
     }
 
-    // Registered call lowerings (#2057) — including the built-in `queryHref`
-    // plugin (#2042), which lowers `queryHref(base, { … })` to a neutral
-    // `guard-list` on the `query` helper → `$bf.query(base, <triples>)`.
-    // Recognised before the support gate because the object-literal arg is
-    // otherwise `unsupported` (BF101). The `query` helper includes a pair iff its
-    // guard is truthy AND its value is a non-empty string (the client's
-    // `if (value)`): a plain `key: v` passes guard `1`, a conditional
-    // `key: cond ? v : undefined` passes the lowered cond. Only the `query`
-    // helper renders to `$bf.query`; another guard-list helper must not be
-    // silently mis-rendered as a query.
-    if (parsed.kind === 'call') {
-      for (const matcher of this._loweringMatchers) {
-        const node = matcher(parsed.callee, parsed.args)
-        if (node?.kind === 'guard-list' && node.helper === 'query') {
-          const qArgs = queryHrefArgs(node, n => this.renderParsedExprToKolon(n))
-          return `$bf.query(${qArgs.join(', ')})`
-        }
-        // Generic `helper-call` (#2069) — the neutral vocabulary's escape
-        // hatch for a userland `LoweringPlugin` that lowers to a single
-        // runtime-helper invocation. `$bf.<helper>(args…)` mirrors the
-        // `query` helper's own naming convention exactly: the framework
-        // renders the call, the plugin author registers `<helper>` as a
-        // Kolon-callable method on the `$bf` vars entry in their own
-        // runtime — same contract as `$bf.query` itself, just not built in.
-        if (node?.kind === 'helper-call' && isValidHelperId(node.helper)) {
-          const argsX = node.args.map(a => this.renderParsedExprToKolon(a))
-          return `$bf.${node.helper}(${argsX.join(', ')})`
-        }
-      }
-    }
-
+    // #2843: a registered lowering plugin's call (the built-in `queryHref`,
+    // or any userland plugin) is recognised no matter where it sits in the
+    // tree — a ternary branch, a template-literal interpolation, … — not
+    // only when `parsed.kind === 'call'` directly. That recognition now
+    // lives in `XslateTopLevelEmitter`'s `lowering` seam, consulted by
+    // `emitParsedExpr`'s shared `call` dispatch; the support gate below is
+    // passed `this._loweringMatchers` so a matched call's params (e.g.
+    // `queryHref`'s object literal, otherwise `unsupported` at `rendered`
+    // position) are admitted wherever the call is nested.
+    //
     // `pos` distinguishes a derived-seed RHS (an assignment, checked via
     // `isSupportedValue`) from every other, genuinely rendered call site —
     // the rendered gate would otherwise re-refuse a tree the seed plan
     // already classified `derived` at value position (#2696 review).
-    const support = pos === 'value' ? isSupportedValue(parsed) : isSupported(parsed)
+    const supportOpts = { loweringMatchers: this._loweringMatchers }
+    const support = pos === 'value' ? isSupportedValue(parsed, supportOpts) : isSupported(parsed, supportOpts)
     if (!support.supported) {
       this.errors.push({
         code: 'BF101',
@@ -1810,7 +1816,7 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
    */
   parseUndefinedAlternateTernary(
     expr: string,
-  ): { condition: string; consequent: string } | null {
+  ): { condition: string; consequent: string; testParsed: ParsedExpr; consequentParsed: ParsedExpr } | null {
     const parsed = parseExpression(expr.trim())
     if (parsed?.kind !== 'conditional') return null
     const alt = parsed.alternate
@@ -1818,13 +1824,16 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
       (alt.kind === 'identifier' && (alt.name === 'undefined' || alt.name === 'null')) ||
       (alt.kind === 'literal' && (alt.value === null || alt.value === undefined))
     if (!isUndef) return null
-    // Serialise the parsed sub-expressions back to JS source rather than
-    // slicing `expr` text — `indexOf('?')` / `lastIndexOf(':')` would
-    // mis-split when the consequent itself contains `?` / `:` inside a
-    // string or nested ternary (`cond ? 'a:b' : undefined`).
+    // `condition`/`consequent` are DEBUG text only (`exprToString` renders an
+    // unsupported nested shape like an object literal as non-reparseable
+    // `[UNSUPPORTED: …]` text) — callers that need to re-lower the
+    // sub-expression must use `testParsed`/`consequentParsed` (the actual
+    // parsed trees) as `preParsed`, not re-parse these strings.
     return {
       condition: exprToString(parsed.test),
       consequent: exprToString(parsed.consequent),
+      testParsed: parsed.test,
+      consequentParsed: parsed.consequent,
     }
   }
 

package/src/conformance-pins.ts

@@ -10,6 +10,10 @@
 import type { ConformancePins } from '@barefootjs/jsx'
 
 export const conformancePins: ConformancePins = {
+  // #2843: graduated — a registered lowering call inside a ternary
+  // attribute branch (or any nested value position) is now recognised via
+  // `XslateTopLevelEmitter`'s `lowering` seam + the registry-aware support
+  // gate, matching the direct-call attribute path exactly.
   'filter-typeof-predicate': [{ code: 'BF021', severity: 'error' }],
   'map-array-builder-body': [{ code: 'BF021', severity: 'error' }],
   'map-array-builder-escaping': [{ code: 'BF021', severity: 'error' }],
@@ -63,4 +67,11 @@ export const conformancePins: ConformancePins = {
   // `rich-prop-client-read` above.
   'jsx-element-prop-ternary': [{ code: 'BF021', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2667' }],
   'jsx-element-prop-array': [{ code: 'BF021', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2667' }],
+  // #2771: a reactive primitive invoked through a namespace import
+  // (`import * as bf from '@barefootjs/client'`, `bf.createSignal(...)`)
+  // that the analyzer's checker-less fast path cannot recognize refuses
+  // loudly (BF013) instead of silently dropping the declaration — fired
+  // in the shared analyzer pass ahead of any adapter's `adapter.generate()`,
+  // so all nine adapters (including Hono) pin this identically.
+  'namespace-import-primitive': [{ code: 'BF013', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2771' }],
 }

package/src/render-divergences.ts

@@ -22,4 +22,7 @@ import type { RenderDivergences } from '@barefootjs/jsx'
 // the real name off that capture — the same in-template recompute the other
 // six template-stash backends already had. Keep the file even when the set
 // is empty — the next divergence lands here, not in a re-created file.
-export const renderDivergences: RenderDivergences = {}
+export const renderDivergences: RenderDivergences = {
+  'aliased-loop-source':
+    'A `.map()` loop whose source is a local const alias of a signal getter (`const items__alias = items`) SSRs an empty `<ul>` on real Text::Xslate — the seeded loop data is keyed by the signal\'s real name (`items`), and the alias hop is never resolved when deciding what to seed under `items__alias`. This is the SSR-side twin of #2778 (fixed for the CSR client-JS template in the same PR that added this fixture) — that fix only touches client-JS emission, not SSR data-seeding. Tracked at https://github.com/piconic-ai/barefootjs/issues/2813; graduate by resolving the alias hop at SSR-seeding time using the same `resolveAliasOrigin`/`resolveGetterAliases` mechanism #2778 introduced, rather than a third alias-hop walker.',
+}