@barefootjs/jsx 0.4.0 → 0.5.0

package/src/__tests__/ir-sort-comparator.test.ts

@@ -31,9 +31,10 @@ describe('sort().map() / toSorted().map()', () => {
       expect(loop).toBeDefined()
       if (loop?.type === 'loop') {
         expect(loop.sortComparator).toBeDefined()
-        expect(loop.sortComparator!.key).toEqual({ kind: 'field', field: 'price' })
-        expect(loop.sortComparator!.type).toBe('numeric')
-        expect(loop.sortComparator!.direction).toBe('asc')
+        expect(loop.sortComparator!.keys).toHaveLength(1)
+        expect(loop.sortComparator!.keys[0].key).toEqual({ kind: 'field', field: 'price' })
+        expect(loop.sortComparator!.keys[0].type).toBe('numeric')
+        expect(loop.sortComparator!.keys[0].direction).toBe('asc')
         expect(loop.sortComparator!.method).toBe('sort')
         expect(loop.sortComparator!.paramA).toBe('a')
         expect(loop.sortComparator!.paramB).toBe('b')
@@ -69,9 +70,10 @@ describe('sort().map() / toSorted().map()', () => {
       expect(loop).toBeDefined()
       if (loop?.type === 'loop') {
         expect(loop.sortComparator).toBeDefined()
-        expect(loop.sortComparator!.key).toEqual({ kind: 'field', field: 'price' })
-        expect(loop.sortComparator!.type).toBe('numeric')
-        expect(loop.sortComparator!.direction).toBe('desc')
+        expect(loop.sortComparator!.keys).toHaveLength(1)
+        expect(loop.sortComparator!.keys[0].key).toEqual({ kind: 'field', field: 'price' })
+        expect(loop.sortComparator!.keys[0].type).toBe('numeric')
+        expect(loop.sortComparator!.keys[0].direction).toBe('desc')
         expect(loop.sortComparator!.method).toBe('toSorted')
       }
     }
@@ -105,9 +107,10 @@ describe('sort().map() / toSorted().map()', () => {
         expect(loop.filterPredicate).toBeDefined()
         expect(loop.filterPredicate!.param).toBe('t')
         expect(loop.sortComparator).toBeDefined()
-        expect(loop.sortComparator!.key).toEqual({ kind: 'field', field: 'priority' })
-        expect(loop.sortComparator!.type).toBe('numeric')
-        expect(loop.sortComparator!.direction).toBe('asc')
+        expect(loop.sortComparator!.keys).toHaveLength(1)
+        expect(loop.sortComparator!.keys[0].key).toEqual({ kind: 'field', field: 'priority' })
+        expect(loop.sortComparator!.keys[0].type).toBe('numeric')
+        expect(loop.sortComparator!.keys[0].direction).toBe('asc')
         expect(loop.chainOrder).toBe('filter-sort')
         expect(loop.array).toBe('todos()')
       }
@@ -147,6 +150,206 @@ describe('sort().map() / toSorted().map()', () => {
     }
   })
 
+  test('multi-key (||-chain) produces one SortKey per operand', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function ProductList() {
+        const [products, setProducts] = createSignal<any[]>([])
+        return (
+          <ul>
+            {products().sort((a, b) => b.price - a.price || a.name.localeCompare(b.name)).map(p => (
+              <li>{p.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'ProductList.tsx')
+    const ir = jsxToIR(ctx)
+
+    expect(ir).not.toBeNull()
+    if (ir!.type === 'element') {
+      const loop = ir!.children.find(c => c.type === 'loop')
+      expect(loop?.type).toBe('loop')
+      if (loop?.type === 'loop') {
+        expect(loop.sortComparator).toBeDefined()
+        expect(loop.sortComparator!.keys).toEqual([
+          { key: { kind: 'field', field: 'price' }, type: 'numeric', direction: 'desc' },
+          { key: { kind: 'field', field: 'name' }, type: 'string', direction: 'asc' },
+        ])
+      }
+    }
+  })
+
+  test('relational ternary comparator lowers to an auto key', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function ProductList() {
+        const [products, setProducts] = createSignal<any[]>([])
+        return (
+          <ul>
+            {products().toSorted((a, b) => a.rank > b.rank ? 1 : -1).map(p => (
+              <li>{p.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'ProductList.tsx')
+    const ir = jsxToIR(ctx)
+
+    expect(ir).not.toBeNull()
+    if (ir!.type === 'element') {
+      const loop = ir!.children.find(c => c.type === 'loop')
+      if (loop?.type === 'loop') {
+        expect(loop.sortComparator).toBeDefined()
+        expect(loop.sortComparator!.keys).toEqual([
+          { key: { kind: 'field', field: 'rank' }, type: 'auto', direction: 'asc' },
+        ])
+      }
+    }
+  })
+
+  test('3-way ternary comparator derives direction from the outer comparison', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function NumList() {
+        const [nums, setNums] = createSignal<number[]>([])
+        return (
+          <ul>
+            {nums().sort((a, b) => a < b ? -1 : a > b ? 1 : 0).map(n => (
+              <li>{n}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'NumList.tsx')
+    const ir = jsxToIR(ctx)
+
+    expect(ir).not.toBeNull()
+    if (ir!.type === 'element') {
+      const loop = ir!.children.find(c => c.type === 'loop')
+      if (loop?.type === 'loop') {
+        expect(loop.sortComparator).toBeDefined()
+        expect(loop.sortComparator!.keys).toEqual([
+          { key: { kind: 'self' }, type: 'auto', direction: 'asc' },
+        ])
+      }
+    }
+  })
+
+  test('arrow block body with single return unwraps to the comparator', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function ProductList() {
+        const [products, setProducts] = createSignal<any[]>([])
+        return (
+          <ul>
+            {products().sort((a, b) => { return a.price - b.price }).map(p => (
+              <li>{p.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'ProductList.tsx')
+    const ir = jsxToIR(ctx)
+
+    expect(ir).not.toBeNull()
+    if (ir!.type === 'element') {
+      const loop = ir!.children.find(c => c.type === 'loop')
+      if (loop?.type === 'loop') {
+        expect(loop.sortComparator).toBeDefined()
+        expect(loop.sortComparator!.keys).toEqual([
+          { key: { kind: 'field', field: 'price' }, type: 'numeric', direction: 'asc' },
+        ])
+        // block body unwraps to the returned expression, keeping the
+        // @client fallback's synthetic `(a, b) => raw` arrow valid.
+        expect(loop.sortComparator!.raw).toBe('a.price - b.price')
+      }
+    }
+  })
+
+  test('leading-equality 3-way ternary (a.f === b.f ? 0 : …) lowers to an auto key', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function ProductList() {
+        const [products, setProducts] = createSignal<any[]>([])
+        return (
+          <ul>
+            {products().toSorted((a, b) => a.rank === b.rank ? 0 : a.rank > b.rank ? 1 : -1).map(p => (
+              <li>{p.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'ProductList.tsx')
+    const ir = jsxToIR(ctx)
+
+    expect(ir).not.toBeNull()
+    if (ir!.type === 'element') {
+      const loop = ir!.children.find(c => c.type === 'loop')
+      if (loop?.type === 'loop') {
+        expect(loop.sortComparator).toBeDefined()
+        // The `=== ? 0` arm is a tie; direction comes from the inner
+        // relational ternary (a.rank > b.rank ? 1 : -1 → ascending).
+        expect(loop.sortComparator!.keys).toEqual([
+          { key: { kind: 'field', field: 'rank' }, type: 'auto', direction: 'asc' },
+        ])
+      }
+    }
+  })
+
+  test('multi-key mixing a numeric leaf and an auto (ternary) leaf', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function ProductList() {
+        const [products, setProducts] = createSignal<any[]>([])
+        return (
+          <ul>
+            {products().sort((a, b) => a.price - b.price || (a.rank > b.rank ? 1 : -1)).map(p => (
+              <li>{p.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'ProductList.tsx')
+    const ir = jsxToIR(ctx)
+
+    expect(ir).not.toBeNull()
+    if (ir!.type === 'element') {
+      const loop = ir!.children.find(c => c.type === 'loop')
+      if (loop?.type === 'loop') {
+        expect(loop.sortComparator).toBeDefined()
+        expect(loop.sortComparator!.keys).toEqual([
+          { key: { kind: 'field', field: 'price' }, type: 'numeric', direction: 'asc' },
+          { key: { kind: 'field', field: 'rank' }, type: 'auto', direction: 'asc' },
+        ])
+      }
+    }
+  })
+
   test('complex sort comparator with @client keeps sort in array', () => {
     const source = `
       'use client'

package/src/__tests__/token-contains-ident.test.ts

@@ -129,6 +129,33 @@ describe('tokenContainsIdent', () => {
     })
   })
 
+  // Regex literals were invisible to the previous hand-rolled char scanner:
+  // a lone quote inside the regex flipped it into string state (swallowing
+  // real references), and an identifier inside the regex body was counted as
+  // a reference. The shared ts.createScanner-based lexer recognises regex
+  // literals, so both cases are now correct (#1370).
+  describe('regex literals', () => {
+    test('reference after a regex literal containing an apostrophe', () => {
+      expect(tokenContainsIdent("/it's/.test(className)", 'className')).toBe(true)
+    })
+
+    test('reference after a regex literal containing a quote', () => {
+      expect(tokenContainsIdent('/a"b/.test(className)', 'className')).toBe(true)
+    })
+
+    test('identifier inside a regex body is not a reference', () => {
+      expect(tokenContainsIdent('/className/.test(x)', 'className')).toBe(false)
+    })
+
+    test('regex with escaped slash does not leak into following code', () => {
+      expect(tokenContainsIdent('/a\\/b/.test(className)', 'className')).toBe(true)
+    })
+
+    test('division is not mistaken for a regex literal', () => {
+      expect(tokenContainsIdent('total / className', 'className')).toBe(true)
+    })
+  })
+
   describe('non-matches', () => {
     test('substring is not a match (word boundary)', () => {
       expect(tokenContainsIdent('myClassName', 'className')).toBe(false)

package/src/__tests__/unsupported-expression.test.ts

@@ -136,21 +136,22 @@ describe('Unsupported Expression Error (BF021)', () => {
 })
 
 describe('Unsupported Sort Comparator (BF021)', () => {
-  test('emits BF021 for multi-key comparator (||-chained) — outside accepted catalogue', () => {
-    // #1448 Tier B widened the accepted catalogue to include
-    // `.localeCompare` and primitive `(a,b) => a - b`. Multi-key
-    // shapes (`a.x - b.x || a.y - b.y`) are still out of scope —
-    // they refuse here and must be `@client`-marked or rewritten
-    // to a single-key sort.
+  test('emits BF021 for function-reference comparator — outside accepted catalogue', () => {
+    // #1448 Tier B follow-up widened the catalogue to include
+    // multi-key (`a.x - b.x || a.y - b.y`), relational ternary, and
+    // single-`return` block bodies. Function-reference comparators
+    // (`arr.sort(cmp)` where `cmp` is a named function) are still out
+    // of scope — they need scope resolution and refuse here.
     const source = `
       'use client'
       import { createSignal } from '@barefootjs/client'
 
       export function TodoList() {
         const [items, setItems] = createSignal<any[]>([])
+        const cmp = (a, b) => a.priority - b.priority
         return (
           <ul>
-            {items().sort((a, b) => a.priority - b.priority || a.id - b.id).map(t => (
+            {items().sort(cmp).map(t => (
               <li>{t.name}</li>
             ))}
           </ul>
@@ -162,7 +163,6 @@ describe('Unsupported Sort Comparator (BF021)', () => {
     const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
 
     expect(bf021).toHaveLength(1)
-    expect(bf021[0].message).toContain('not a supported shape')
   })
 
   test('@client suppresses BF021 for unsupported sort comparator', () => {
@@ -172,9 +172,10 @@ describe('Unsupported Sort Comparator (BF021)', () => {
 
       export function TodoList() {
         const [items, setItems] = createSignal<any[]>([])
+        const cmp = (a, b) => a.priority - b.priority
         return (
           <ul>
-            {/* @client */ items().sort((a, b) => a.priority - b.priority || a.id - b.id).map(t => (
+            {/* @client */ items().sort(cmp).map(t => (
               <li>{t.name}</li>
             ))}
           </ul>
@@ -188,9 +189,37 @@ describe('Unsupported Sort Comparator (BF021)', () => {
     expect(bf021).toHaveLength(0)
   })
 
-  test('emits BF021 error for block body sort comparator', () => {
-    // Block-body comparators are deferred to a Tier B follow-up
-    // (the extractor only handles expression-body shapes for now).
+  test('emits BF021 for localeCompare with a locale/options argument', () => {
+    // The zero-arg `a.f.localeCompare(b.f)` form lowers, but the
+    // locale/options form needs per-adapter collation plumbing and
+    // stays refused (deferred #1448 Tier B follow-up).
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function TodoList() {
+        const [items, setItems] = createSignal<any[]>([])
+        return (
+          <ul>
+            {items().sort((a, b) => a.name.localeCompare(b.name, 'en', { numeric: true })).map(t => (
+              <li>{t.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const { errors } = compileToIR(source)
+    const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+
+    expect(bf021).toHaveLength(1)
+    expect(bf021[0].message).toContain('not a supported shape')
+  })
+
+  test('emits BF021 error for multi-statement block-body sort comparator', () => {
+    // Single-`return` block bodies now lower (#1448 Tier B follow-up),
+    // but multi-statement / local-var bodies stay refused — generalising
+    // over arbitrary statement sequences isn't tractable in a template.
     const source = `
       'use client'
       import { createSignal } from '@barefootjs/client'
@@ -199,7 +228,7 @@ describe('Unsupported Sort Comparator (BF021)', () => {
         const [items, setItems] = createSignal<any[]>([])
         return (
           <ul>
-            {items().sort((a, b) => { return a.price - b.price }).map(t => (
+            {items().sort((a, b) => { const x = a.price; return x - b.price }).map(t => (
               <li>{t.name}</li>
             ))}
           </ul>

package/src/adapters/interface.ts

@@ -123,6 +123,26 @@ export interface TemplateAdapter {
    * Required for adapters that look up templates by filename (e.g. Mojolicious).
    */
   templatesPerComponent?: boolean
+  /**
+   * How the application author injects the externals importmap (and any
+   * `<link rel="modulepreload">` hints) into the page `<head>` when
+   * `externals` / `bundleEntries` are configured.
+   *
+   * - `'component'` — the adapter ships a render-time component (e.g. Hono's
+   *   `BfImportMap`) that reads `barefoot-externals.json`; `bf build` emits no
+   *   static snippet.
+   * - `'html-snippet'` — the adapter targets a template-string language (Go
+   *   html/template, Mojolicious EP) with no component layer, so `bf build`
+   *   writes a ready-to-include `barefoot-importmap.html` alongside
+   *   `barefoot-externals.json` (via `renderImportMapHtml`).
+   *
+   * Optional only for backward compatibility (and internal-only adapters like
+   * the CSR test adapter). Every *shipping* adapter must set it — the
+   * adapter-tests importmap-injection contract enforces this so a new adapter
+   * cannot silently leave configured `externals` with no injection point.
+   * See issue #1644.
+   */
+  importMapInjection?: 'component' | 'html-snippet'
   /**
    * Module specifier of the SSR shim for `@barefootjs/client` (and
    * `/runtime`). When set, the compiler rewrites client-package imports in