@barefootjs/jinja 0.30.6 → 0.31.0

package/src/vite.ts

@@ -0,0 +1,215 @@
+/**
+ * `@barefootjs/jinja/vite` — a Jinja2-specific COMPOSITION of core
+ * `@barefootjs/vite`'s `barefoot()`, mirroring `@barefootjs/go-template/
+ * vite`'s, `@barefootjs/hono/vite`'s, and `@barefootjs/blade/vite`'s shape
+ * and naming (`barefoot`, named AND default export; a user never passes
+ * `adapter`, this constructs `JinjaAdapter` itself).
+ *
+ *   import { barefoot } from '@barefootjs/jinja/vite'
+ *
+ *   export default defineConfig({
+ *     base: '/integrations/django/client/',
+ *     build: { outDir: 'dist/client' },
+ *     plugins: barefoot({
+ *       components: ['../shared/components', '../shared/blog'],
+ *       templates: 'dist/templates',
+ *     }),
+ *   })
+ *
+ * ## Why this needs no `afterEmit`-driven type-combination step (unlike Go)
+ *
+ * `@barefootjs/go-template/vite` exists mainly to combine every discovered
+ * file's `types` fragment into ONE compilable `components.go` — Go's
+ * per-file fragments assume a shared `randomID` helper and a single package
+ * header, so they are not independently valid Go source, and an unused
+ * import fails the build outright (see that module's docstring).
+ * `JinjaAdapter.generate()` never produces a `types` section at all (Jinja2
+ * templates have no JS-style imports/types/exports to combine — see
+ * `jinja-adapter.ts`'s `generate()`, whose `sections.types` is always
+ * `''`), so there is nothing across files to stitch together, and no
+ * unused-import failure mode to guard against either. So this composition's
+ * core job is just what core's `barefoot()` already does: construct
+ * `JinjaAdapter` and hand it to core.
+ *
+ * ## No `adapterOptions` either — the other thing Go/Hono still need
+ *
+ * `JinjaAdapterOptions` has exactly two fields, `clientJsBasePath` and
+ * `barefootJsPath` — and `JinjaAdapter.generateScriptRegistrations` only
+ * falls back to them when `scriptAssets` is `undefined` (i.e. the adapter
+ * is invoked without this Vite plugin). Core's `barefoot()` plugin ALWAYS
+ * passes a resolved `scriptAssets` array (build: manifest-hashed; dev:
+ * origin-based — see `plugin.ts`), so that fallback is dead code on every
+ * Vite-driven build.
+ * Unlike Go (`packageName`, still real) or Hono (`clientJsFilename`, still
+ * real), Jinja has no adapter option left with any effect once Vite drives
+ * the build — so this options interface simply omits the field rather than
+ * plumbing through two options that would always be ignored.
+ *
+ * ## `assets` — the one thing this DOES need, mirroring go-template/hono/blade
+ *
+ * A hand-written, non-component client bootstrap (e.g. an integration's
+ * `client/router-entry.ts`, which boots `@barefootjs/router` for the blog)
+ * isn't a `.tsx` component, so core's own discovery/`scriptAssets` machinery
+ * never sees it — but the compiled blog shell still needs a `<script src>`
+ * for it, and that URL is only knowable after Vite bundles it (dev:
+ * origin-based; build: manifest-hashed). `assets` resolves exactly that,
+ * into a generated JSON file the Python app reads at request time (the same
+ * `dist/templates/manifest.json` — read-a-JSON-file-at-runtime — idiom
+ * app.py already uses for `ssrDefaults`; unlike Go/Hono there is no compile
+ * step on the Python side, so plain JSON is enough — no generated Go/TS
+ * source needed). See `@barefootjs/go-template/vite`'s docstring for the
+ * full "why a companion config-capture plugin" rationale (`afterEmit`'s
+ * `AfterEmitContext` is deliberately narrow — no `ResolvedConfig`, no dev
+ * origin, no manifest — so a tiny second plugin captures those via its own
+ * `configResolved`/`configureServer` hooks for `afterEmit`, in the same
+ * closure, to read).
+ */
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import type { Plugin, ResolvedConfig, ViteDevServer } from 'vite'
+import { barefoot as coreBarefoot } from '@barefootjs/vite'
+import type { AfterEmitContext } from '@barefootjs/vite'
+import { devModuleUrl, loadManifest, resolveDevOrigin, resolveScriptAssets, toPosixRelative } from '@barefootjs/vite'
+import { JinjaAdapter } from './adapter/index.ts'
+
+export interface JinjaViteOptions {
+  /** Source directories to scan for `.tsx` components, relative to the
+   * Vite project root (or absolute). */
+  components: string[]
+  /** Where compiled `.jinja` templates and `ssrDefaults` land — relative to
+   * the Vite project root (or absolute). This is a backend source
+   * directory Python reads, NOT `build.outDir` (Vite's client-asset
+   * output). */
+  templates: string
+  /**
+   * Extra, non-component script entries whose Vite-resolved URL (dev:
+   * origin-based; production: content-hashed manifest path) should be
+   * exposed to the Python app as a generated JSON asset map — e.g. a
+   * hand-written client bootstrap script that isn't a `.tsx` component, so
+   * it never goes through core's discovery/`scriptAssets` machinery, but
+   * still needs a `<script src="...">` URL only knowable after bundling.
+   *
+   * Keyed by the identifier the resolved URL should appear under in the
+   * generated map; values are entry paths relative to the Vite project
+   * root. You must ALSO register the same path as a Rollup entry yourself
+   * via stock `build.rollupOptions.input` — this plugin never adds
+   * bundling configuration on your behalf; this option only resolves the
+   * URL Vite already bundled it to, it doesn't request the bundling.
+   */
+  assets?: Record<string, string>
+  /** Output path for the generated JSON asset map, relative to the Vite
+   * project root. Default: 'dist/bf-assets.json'. Ignored when `assets`
+   * is empty. Placed under `dist/` (already gitignored) rather than
+   * committed like Go's `bf_assets.go`: Python reads this file at REQUEST
+   * time, so — unlike Go, which must compile a static map into the
+   * binary — there is nothing to commit; a fresh copy is generated on
+   * every build (dev AND production) and never checked in. */
+  assetsOutputFile?: string
+}
+
+/** write-if-changed: writes `content` to `absPath` only if it differs from
+ * what's already there, logging `label` when it actually wrote. Avoids
+ * touching mtime (and so falsely tripping a file watcher, e.g. Python's own
+ * dev server) on a pass that produced byte-identical output. */
+async function writeIfChanged(absPath: string, content: string, label: string): Promise<void> {
+  const prev = await readFile(absPath, 'utf-8').catch(() => null)
+  if (prev === content) return
+  // Default `assetsOutputFile` lives under `dist/` — a directory `vite
+  // build` may not have created yet on a clean checkout — so ensure it
+  // exists before writing.
+  await mkdir(dirname(absPath), { recursive: true })
+  await writeFile(absPath, content)
+  console.log(`Generated: ${label}`)
+}
+
+/** Resolves ONE asset entry's URL for the current pass: manifest-hashed for
+ * `mode: 'build'`, dev-origin-based for `mode: 'dev'`. Throws with an
+ * actionable message when the entry isn't in the build manifest — almost
+ * always means the caller forgot to also add it to
+ * `build.rollupOptions.input`. */
+function resolveAssetUrl(
+  ctx: AfterEmitContext,
+  config: ResolvedConfig,
+  devServer: ViteDevServer | undefined,
+  entryRelPath: string,
+  manifest: Record<string, { file: string }> | undefined,
+): string {
+  const absPath = resolve(ctx.projectDir, entryRelPath)
+  if (ctx.mode === 'dev') {
+    if (!devServer) throw new Error(`[jinja/vite] asset "${entryRelPath}": dev server not ready`)
+    return devModuleUrl(config, resolveDevOrigin(devServer), absPath)
+  }
+
+  const manifestKey = toPosixRelative(config.root, absPath)
+  const [url] = resolveScriptAssets(manifest ?? {}, manifestKey, config.base)
+  if (!url) {
+    throw new Error(
+      `[jinja/vite] asset "${entryRelPath}" was not found in the build manifest. ` +
+        `Did you also add it to build.rollupOptions.input?`,
+    )
+  }
+  return url
+}
+
+/** Builds and write-if-changed's the generated JSON asset map. No-op when
+ * `assets` is empty. */
+async function writeAssetMap(
+  ctx: AfterEmitContext,
+  config: ResolvedConfig,
+  devServer: ViteDevServer | undefined,
+  assets: Record<string, string>,
+  assetsOutputFile: string,
+): Promise<void> {
+  const keys = Object.keys(assets)
+  if (keys.length === 0) return
+
+  const manifest = ctx.mode === 'build' ? await loadManifest(ctx.outDir, config.build.manifest) : undefined
+
+  const resolved: Record<string, string> = {}
+  for (const name of keys) {
+    resolved[name] = resolveAssetUrl(ctx, config, devServer, assets[name]!, manifest)
+  }
+
+  const content = `${JSON.stringify(resolved, null, 2)}\n`
+  await writeIfChanged(resolve(ctx.projectDir, assetsOutputFile), content, assetsOutputFile)
+}
+
+export function barefoot(options: JinjaViteOptions): Plugin[] {
+  const assets = options.assets ?? {}
+  const assetsOutputFile = options.assetsOutputFile ?? 'dist/bf-assets.json'
+
+  // Populated by `jinjaAssetsConfigCapture` below (only added to the
+  // returned array when `assets` is non-empty). Read by `afterEmit` — see
+  // `@barefootjs/go-template/vite`'s identical mechanism for the ordering
+  // guarantee (`configResolved`/`configureServer` always run before the
+  // eager pass that triggers `afterEmit`, for both build and dev).
+  let resolvedConfig: ResolvedConfig | undefined
+  let devServer: ViteDevServer | undefined
+
+  const core = coreBarefoot({
+    adapter: new JinjaAdapter(),
+    components: options.components,
+    templates: options.templates,
+    async afterEmit(ctx) {
+      if (Object.keys(assets).length > 0 && resolvedConfig) {
+        await writeAssetMap(ctx, resolvedConfig, devServer, assets, assetsOutputFile)
+      }
+    },
+  })
+
+  if (Object.keys(assets).length === 0) return [core]
+
+  const jinjaAssetsConfigCapture: Plugin = {
+    name: 'barefoot-jinja-assets-config-capture',
+    configResolved(config) {
+      resolvedConfig = config
+    },
+    configureServer(server) {
+      devServer = server
+    },
+  }
+
+  return [core, jinjaAssetsConfigCapture]
+}
+
+export { barefoot as default }

package/dist/build.d.ts

@@ -1,28 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}