@barefootjs/vite 0.31.3 → 0.31.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/vite",
-  "version": "0.31.3",
+  "version": "0.31.5",
   "description": "Vite plugin for BarefootJS: Vite/Rollup owns bundling, hashing, chunking, tree-shaking and minification of client assets, BarefootJS keeps only the JSX to (template, client JS) compile",
   "type": "module",
   "main": "./dist/index.js",
@@ -38,17 +38,17 @@
     "directory": "packages/vite"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.31.3"
+    "@barefootjs/shared": "0.31.5"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
     "vite": "^6.0.0"
   },
   "devDependencies": {
-    "@barefootjs/client": "0.31.3",
-    "@barefootjs/go-template": "0.31.3",
-    "@barefootjs/hono": "0.31.3",
-    "@barefootjs/jsx": "0.31.3",
+    "@barefootjs/client": "0.31.5",
+    "@barefootjs/go-template": "0.31.5",
+    "@barefootjs/hono": "0.31.5",
+    "@barefootjs/jsx": "0.31.5",
     "typescript": "^5.0.0",
     "vite": "^6.0.0"
   }

package/src/__tests__/dynamic-import-rewrite.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Regression (#2588): a relative specifier inside a DYNAMIC `import()` must
+ * be re-anchored to the emitted template's directory, exactly like the
+ * static `import` statements `rewriteImportsForTemplate` already handles.
+ *
+ * Dynamic imports never reach `ir.metadata.templateImports` — they ride
+ * along inside declaration source text that the adapter re-emits verbatim
+ * (`generateModuleScopeDeclarations`' consts/functions, and a component
+ * body's local handlers). Before the fix they were emitted untouched, so a
+ * specifier written relative to `components/` still said `../lib/heavy`
+ * once the template landed in `app/dist/components/` — a path that does
+ * not exist. The backend bundler then hard-fails (`Could not resolve
+ * "../lib/heavy"`), so this is a build break, not a type-only defect.
+ *
+ * The fixture mirrors the layout that hits this in the wild (piconic-ai/koma):
+ * a `components` dir and a plain `lib` dir side by side, with templates
+ * emitted to a DEEPER directory — root-relative and template-relative only
+ * diverge when the two depths differ, so a flat layout would not reproduce.
+ * Lives under `packages/vite/` (not a system tmpdir) so `@barefootjs/client`
+ * resolves through the monorepo's real workspace symlinks — same reason
+ * `e2e-fixture`/`e2e-fixture-dev`/`e2e-fixture-relimport` do.
+ */
+import { describe, test, expect, afterAll } from 'bun:test'
+import { build } from 'vite'
+import { mkdtemp, rm, readFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { HonoAdapter } from '@barefootjs/hono/adapter'
+import { barefoot } from '../plugin.ts'
+
+const FIXTURE_ROOT = resolve(import.meta.dirname, '../../e2e-fixture-dynimport')
+const APP_ROOT = join(FIXTURE_ROOT, 'app')
+const COMPONENTS_DIR = join(FIXTURE_ROOT, 'components')
+
+// `app/dist/components/Lazy.tsx` → up three → the fixture root, where `lib/`
+// sits. The source says `../lib/heavy` from `components/`; the emitted
+// template has to say this instead.
+const REANCHORED = '../../../lib/heavy'
+
+describe('dynamic import() re-anchoring in emitted templates', () => {
+  let outDir: string
+  let templatesDir: string
+
+  afterAll(async () => {
+    await rm(outDir, { recursive: true, force: true })
+    await rm(join(APP_ROOT, 'dist'), { recursive: true, force: true })
+  })
+
+  test('re-anchors dynamic imports at module scope, in type position, and inside a component body', async () => {
+    outDir = await mkdtemp(join(tmpdir(), 'barefoot-vite-dynimport-dist-'))
+    templatesDir = join(APP_ROOT, 'dist/components')
+
+    await build({
+      configFile: false,
+      root: APP_ROOT,
+      base: '/static/',
+      logLevel: 'warn',
+      build: { outDir, emptyOutDir: true },
+      plugins: [
+        barefoot({
+          adapter: new HonoAdapter(),
+          components: [COMPONENTS_DIR],
+          templates: templatesDir,
+        }),
+      ],
+    })
+
+    const template = await readFile(join(templatesDir, 'Lazy.tsx'), 'utf8')
+
+    // Nothing anywhere may still carry the source-relative form. Asserted
+    // first and globally: a per-site check would pass while some fourth
+    // emission path silently leaked the old specifier.
+    expect(template).not.toContain("'../lib/heavy'")
+
+    // Module scope, TYPE position — `typeof import('…')` is an
+    // ImportTypeNode, a different AST node from the call expression below,
+    // and was missed independently.
+    expect(template).toContain(`typeof import('${REANCHORED}')`)
+
+    // Module scope, VALUE position — inside a re-emitted const's body.
+    expect(template).toContain(`modPromise = import('${REANCHORED}')`)
+
+    // Component scope — inside a local handler in the component body,
+    // which is emitted by a different code path than module declarations.
+    expect(template).toContain(`await import('${REANCHORED}')`)
+
+    // The re-anchored path must actually resolve on disk from the emitted
+    // template's own directory — the assertions above only pin the string.
+    const target = resolve(templatesDir, REANCHORED + '.ts')
+    expect(await readFile(target, 'utf8')).toContain('export function heavy')
+  }, 60_000)
+})

package/src/__tests__/mutable-binding-writers.test.ts

@@ -0,0 +1,116 @@
+/**
+ * Regression (#2598): a mutable binding that survives into the emitted SSR
+ * template must keep the declarations that WRITE it.
+ *
+ * Reachability is seeded from the RENDERED JSX, after the client-only
+ * attributes are stripped — `ref={setRef}` leaves no `setRef` behind, and
+ * `onClick={handleClick}` renders as `onClick={() => {}}`. Pruning code
+ * reachable only from a handler is deliberate; it is client-only.
+ *
+ * The hole is a `let` that outlives its writer. It survives because some
+ * OTHER surviving declaration reads it, while its only assignment sat in a
+ * pruned handler — so the template declares it, reads it, and never assigns
+ * it. TypeScript then concludes it is permanently `null`, narrows every
+ * guarded use to `never`, and each member access fails with TS2339.
+ *
+ * The fixture reproduces the shape from the wild (piconic-ai/koma's
+ * FrameEditor), and the asymmetry that makes it reachable at all:
+ *
+ *   <pre ref={handleHighlightRef} />   intrinsic — `ref` is STRIPPED, so
+ *                                      the handler is pruned
+ *   <Editable ref={handleTextareaRef}/> child component — props survive
+ *                                      VERBATIM, so its handler is kept,
+ *                                      which keeps `syncScroll`, which
+ *                                      keeps `highlightEl` alive with no
+ *                                      writer left
+ *
+ * A fixture with only intrinsic elements does NOT reproduce: the whole
+ * cluster is pruned together and nothing is left to narrow. The child
+ * component is load-bearing.
+ */
+import { describe, test, expect, afterAll } from 'bun:test'
+import { build } from 'vite'
+import { mkdtemp, rm, readFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import ts from 'typescript'
+import { HonoAdapter } from '@barefootjs/hono/adapter'
+import { barefoot } from '../plugin.ts'
+
+const FIXTURE_ROOT = resolve(import.meta.dirname, '../../e2e-fixture-refwriter')
+const APP_ROOT = join(FIXTURE_ROOT, 'app')
+const COMPONENTS_DIR = join(FIXTURE_ROOT, 'components')
+
+describe('writers of surviving mutable bindings', () => {
+  let outDir: string | undefined
+  const templatesDir = join(APP_ROOT, 'dist/components')
+
+  afterAll(async () => {
+    // Guarded: if the test throws before `mkdtemp` returns, `outDir` is still
+    // undefined and an unguarded `rm` would throw here, replacing the real
+    // failure with a cleanup TypeError.
+    if (outDir) await rm(outDir, { recursive: true, force: true })
+    await rm(join(APP_ROOT, 'dist'), { recursive: true, force: true })
+  })
+
+  test('retains a ref handler whose binding survives, and the template type-checks', async () => {
+    outDir = await mkdtemp(join(tmpdir(), 'barefoot-vite-refwriter-dist-'))
+
+    await build({
+      configFile: false,
+      root: APP_ROOT,
+      base: '/static/',
+      logLevel: 'warn',
+      build: { outDir, emptyOutDir: true },
+      plugins: [
+        barefoot({
+          adapter: new HonoAdapter(),
+          components: [COMPONENTS_DIR],
+          templates: templatesDir,
+        }),
+      ],
+    })
+
+    const templatePath = join(templatesDir, 'ScrollSync.tsx')
+    const template = await readFile(templatePath, 'utf8')
+
+    // The binding survives (some surviving declaration reads it) …
+    expect(template).toContain('let highlightEl')
+    // … so its writer must survive with it. This is the line the bug dropped.
+    expect(template).toContain('highlightEl = el')
+
+    // `renderSeq` is written with `++` rather than `=`, from a declaration
+    // retained only by this same closure — pins that update expressions
+    // count as writes, not just assignment operators.
+    expect(template).toContain('let renderSeq')
+    expect(template).toContain('renderSeq++')
+
+    // The symptom itself, not a proxy for it: type-check the emitted
+    // template. Asserting on the retained source line alone would still pass
+    // if some later change made the binding un-narrowable for a different
+    // reason.
+    const program = ts.createProgram([templatePath], {
+      strict: true,
+      noEmit: true,
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      jsx: ts.JsxEmit.ReactJSX,
+      jsxImportSource: '@barefootjs/hono/jsx',
+      lib: ['lib.esnext.d.ts', 'lib.dom.d.ts'],
+      allowImportingTsExtensions: true,
+      skipLibCheck: true,
+    })
+    // Asserted over the WHOLE error set, not a TS2339-only filter: this
+    // fixture's emitted template compiles completely clean today, so any
+    // error at all — a syntax break, an unresolved import, a wrong JSX
+    // setting — is a real regression, and a narrow filter would let those
+    // through while still claiming the template type-checks. TS2339 on
+    // `never` is simply the member of that set this PR is about.
+    const errors = ts
+      .getPreEmitDiagnostics(program)
+      .filter((d) => d.category === ts.DiagnosticCategory.Error)
+      .map((d) => `TS${d.code}: ${ts.flattenDiagnosticMessageText(d.messageText, ' ')}`)
+    expect(errors).toEqual([])
+  }, 60_000)
+})