conjure-js 0.0.12 → 0.0.13

package/src/vite-plugin-clj/codegen.ts

@@ -1,10 +1,8 @@
-import { isMacro } from '../core/assertions'
-import type { Session } from '../core/session'
-import type { Arity, CljValue } from '../core/types'
-import { extractNsName, extractNsRequires } from './namespace-utils'
+import type { Arity, DestructurePattern } from '../core/types'
+import { extractNsName, extractNsRequires, extractStringRequires } from './namespace-utils'
+import { readNamespaceVars } from './static-analysis'
 
 export interface CodegenContext {
-  session: Session
   sourceRoots: string[]
   coreIndexPath: string
   virtualSessionId: string
@@ -14,11 +12,13 @@ export interface CodegenContext {
 export function generateModuleCode(
   ctx: CodegenContext,
   nsNameFromPath: string,
-  source: string
+  source: string,
+  filePath?: string
 ): string {
   const nsName = extractNsName(source) ?? nsNameFromPath
 
-  ctx.session.loadFile(source, nsName)
+  // Detect string requires from AST — determines sync vs async load call.
+  const hasStringRequires = extractStringRequires(source, filePath).length > 0
 
   const requires = extractNsRequires(source)
   const depImports = requires
@@ -30,91 +30,120 @@ export function generateModuleCode(
     .filter(Boolean)
     .join('\n')
 
-  const nsData = ctx.session.getNs(nsName)
-  if (!nsData) {
-    return `throw new Error('Namespace ${nsName} failed to load');`
-  }
-
+  // Static analysis: pure AST walk, no execution.
+  const vars = readNamespaceVars(source)
   const exportLines: string[] = []
-  for (const [name, v] of nsData.vars) {
-    const value = v.value
-    if (isMacro(value)) continue
 
-    const safeName = safeJsIdentifier(name)
+  for (const descriptor of vars) {
+    if (descriptor.isMacro) continue
+    if (descriptor.isPrivate) continue
+
+    const safeName = safeJsIdentifier(descriptor.name)
     // At runtime, vars.get() returns a CljVar; deref with .value
-    const deref = `__ns.vars.get(${JSON.stringify(name)}).value`
-    if (isAFunction(value)) {
+    const deref = `__ns.vars.get(${JSON.stringify(descriptor.name)}).value`
+
+    if (descriptor.kind === 'fn') {
       exportLines.push(
         `export function ${safeName}(...args) {` +
           `  const fn = ${deref};` +
           `  const cljArgs = args.map(jsToClj);` +
-          `  const result = applyFunction(fn, cljArgs);` +
-          `  return cljToJs(result);` +
+          `  const result = __session.applyFunction(fn, cljArgs);` +
+          `  return cljToJs(result, __session);` +
           `}`
       )
     } else {
       exportLines.push(
-        `export const ${safeName} = cljToJs(${deref});`
+        `export const ${safeName} = cljToJs(${deref}, __session);`
       )
     }
   }
 
   const escapedSource = JSON.stringify(source)
+  // Files with string requires need async loading (top-level await, requires target: esnext).
+  // Files without string requires use the sync path — no top-level await overhead.
+  const loadCall = hasStringRequires
+    ? `await __session.loadFileAsync(${escapedSource}, ${JSON.stringify(nsName)});`
+    : `__session.loadFile(${escapedSource}, ${JSON.stringify(nsName)});`
+
+  if (exportLines.length === 0) {
+    // No public exports — emit a minimal module that loads the namespace at runtime.
+    // Namespace will be available in the session even without JS-side exports.
+    return [
+      `import { getSession } from ${JSON.stringify(ctx.virtualSessionId)};`,
+      depImports,
+      ``,
+      `const __session = getSession();`,
+      loadCall,
+      ``,
+      `if (import.meta.hot) { import.meta.hot.accept() }`,
+    ].join('\n')
+  }
 
   return [
     `import { getSession } from ${JSON.stringify(ctx.virtualSessionId)};`,
-    `import { cljToJs, jsToClj, applyFunction } from ${JSON.stringify(ctx.coreIndexPath)};`,
+    `import { cljToJs, jsToClj } from ${JSON.stringify(ctx.coreIndexPath)};`,
     depImports,
     ``,
     `const __session = getSession();`,
-    `__session.loadFile(${escapedSource}, ${JSON.stringify(nsName)});`,
+    loadCall,
     `const __ns = __session.getNs(${JSON.stringify(nsName)});`,
     ``,
     ...exportLines,
+    ``,
+    `// Self-accept HMR: re-execute this module on save (updates browser session)`,
+    `// without propagating to parent modules — prevents full page reload.`,
+    `if (import.meta.hot) { import.meta.hot.accept() }`,
   ].join('\n')
 }
 
-function isAFunction(value: CljValue): boolean {
-  return value.kind === 'function' || value.kind === 'native-function'
-}
+export function generateDts(
+  _ctx: CodegenContext,
+  nsNameFromPath: string,
+  source: string
+): string {
+  const nsName = extractNsName(source) ?? nsNameFromPath
+  const vars = readNamespaceVars(source)
 
-function cljValueToTsType(value: CljValue): string {
-  switch (value.kind) {
-    case 'number':
-      return 'number'
-    case 'string':
-      return 'string'
-    case 'boolean':
-      return 'boolean'
-    case 'nil':
-      return 'null'
-    case 'keyword':
-      return 'string'
-    case 'symbol':
-      return 'string'
-    case 'list':
-    case 'vector':
-      return 'unknown[]'
-    case 'map':
-      return 'Record<string, unknown>'
-    case 'function':
-    case 'native-function':
-      return '(...args: unknown[]) => unknown'
-    case 'macro':
-      return 'never'
-    case 'var':
-      return 'unknown'
-    default:
-      throw new Error(`Unknown CljValue kind: ${value.kind}`)
+  const declarations: string[] = []
+  for (const descriptor of vars) {
+    if (descriptor.isMacro) continue
+    if (descriptor.isPrivate) continue
+
+    const safeName = safeJsIdentifier(descriptor.name)
+
+    if (descriptor.kind === 'fn') {
+      if (descriptor.arities && descriptor.arities.length > 0) {
+        for (const arity of descriptor.arities) {
+          declarations.push(`export function ${safeName}${arityToSignature(arity)};`)
+        }
+      } else {
+        declarations.push(`export function ${safeName}(...args: unknown[]): unknown;`)
+      }
+    } else {
+      // 'const' with inferred type, or 'unknown'
+      const tsType = descriptor.tsType ?? 'unknown'
+      declarations.push(`export const ${safeName}: ${tsType};`)
+    }
   }
+
+  // Suppress the unused-variable warning — nsName is used for documentation only here
+  void nsName
+
+  return declarations.join('\n')
 }
 
+// ---------------------------------------------------------------------------
+// Signature helpers
+// ---------------------------------------------------------------------------
+
+type ArityShape = { params: DestructurePattern[]; restParam: DestructurePattern | null }
+
 function patternName(p: Arity['params'][number], index: number): string {
   if (p.kind === 'symbol') return safeJsIdentifier(p.name)
   return `arg${index}`
 }
 
-function arityToSignature(arity: Arity): string {
+function arityToSignature(arity: ArityShape): string {
   const fixedParams = arity.params
     .map((p, i) => `${patternName(p, i)}: unknown`)
     .join(', ')
@@ -133,46 +162,9 @@ function arityToSignature(arity: Arity): string {
   return `(${fixedParams}): unknown`
 }
 
-export function generateDts(
-  ctx: CodegenContext,
-  nsNameFromPath: string,
-  source: string
-): string {
-  const nsName = extractNsName(source) ?? nsNameFromPath
-
-  try {
-    ctx.session.loadFile(source, nsName)
-  } catch {
-    return ''
-  }
-
-  const nsData = ctx.session.getNs(nsName)
-  if (!nsData) return ''
-
-  const declarations: string[] = []
-  for (const [name, v] of nsData.vars) {
-    const value = v.value
-    if (isMacro(value)) continue
-
-    const safeName = safeJsIdentifier(name)
-
-    if (value.kind === 'function') {
-      for (const arity of value.arities) {
-        declarations.push(
-          `export function ${safeName}${arityToSignature(arity)};`
-        )
-      }
-    } else if (value.kind === 'native-function') {
-      declarations.push(
-        `export function ${safeName}(...args: unknown[]): unknown;`
-      )
-    } else {
-      declarations.push(`export const ${safeName}: ${cljValueToTsType(value)};`)
-    }
-  }
-
-  return declarations.join('\n')
-}
+// ---------------------------------------------------------------------------
+// Identifier sanitization
+// ---------------------------------------------------------------------------
 
 const JS_RESERVED_WORDS = new Set([
   'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger',

package/src/vite-plugin-clj/index.ts

@@ -1,18 +1,31 @@
 import { execFileSync } from 'node:child_process'
 import { readFileSync, writeFileSync, readdirSync, statSync } from 'node:fs'
 import { resolve, relative, join, dirname } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { createRequire } from 'node:module'
 import type { Plugin, ResolvedConfig, ViteDevServer } from 'vite'
 import { createSession } from '../core/session'
 import type { Session } from '../core/session'
-import { nsToPath, pathToNs } from './namespace-utils'
+import { nsToPath, pathToNs, extractStringRequires } from './namespace-utils'
 import { generateModuleCode, generateDts, safeJsIdentifier } from './codegen'
 import type { CodegenContext } from './codegen'
-import { startBrowserNreplRelay } from './nrepl-relay'
+import { startBrowserNreplRelay } from '../nrepl/relay'
 
 interface CljPluginOptions {
   sourceRoots?: string[]
   nreplPort?: number
+  /**
+   * Path to a user-defined session factory (relative to project root).
+   * The factory must be the default export with signature:
+   *   (importMap: Record<string, unknown>) => SessionOptions | null | undefined
+   *
+   * The plugin automatically injects `importModule` (wired to the import map) and
+   * `output` (wired to nREPL output capture + console.log). Do NOT provide these.
+   * Return only what you need: hostBindings, modules, entries, stderr, etc.
+   *
+   * Example: entrypoint: 'src/conjure.ts'
+   */
+  entrypoint?: string
 }
 
 // Resolve the conjure-js core index path regardless of whether this plugin
@@ -42,6 +55,12 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
   let codegenCtx: CodegenContext
   let generatorScriptPath: string
   let serveMode = false
+  // Collected during configResolved: original CLJ source string → resolved path/package name.
+  // Original string = what the CLJ runtime passes to importModule(s).
+  // Resolved = what Vite should actually import (absolute path for relative, unchanged for pkgs).
+  let stringRequires: Array<{ original: string; resolved: string }> = []
+  // Resolved absolute path to the user-defined session entrypoint (Mode 2), or null (Mode 1).
+  let entrypointPath: string | null = null
 
   function writeFileIfChanged(path: string, content: string) {
     try {
@@ -88,7 +107,7 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
           const source = readFileSync(filePath, 'utf-8')
           const nsNameFromPath = pathToNs(relative(projectRoot, filePath), sourceRoots)
           const dts = generateDts(codegenCtx, nsNameFromPath, source)
-          writeFileIfChanged(filePath + '.d.ts', dts)
+          if (dts) writeFileIfChanged(filePath + '.d.ts', dts)
         } catch {
           continue
         }
@@ -97,14 +116,45 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
   }
 
   function initServerSession() {
+    // Use a require resolver anchored to the project root so that the server session
+    // can import npm packages from the consuming project's node_modules (e.g. date-fns),
+    // not just from the plugin's own node_modules.
+    const projectRequire = createRequire(resolve(projectRoot, 'package.json'))
+
     serverSession = createSession({
       sourceRoots,
       readFile: (filePath: string) =>
         readFileSync(resolve(projectRoot, filePath), 'utf-8'),
       output: () => {},
+      // Node dynamic import — used only during server-side code generation (DTS inference).
+      // In the browser bundle, importModule is a synchronous import map lookup instead.
+      importModule: async (s: string) => {
+        if (!s.startsWith('.') && !s.startsWith('/')) {
+          // Package import: resolve from project root context so the consuming project's
+          // node_modules are searched instead of (or in addition to) the plugin's.
+          try {
+            const resolved = projectRequire.resolve(s)
+            return import(pathToFileURL(resolved).href)
+          } catch {
+            try {
+              return await import(s)
+            } catch {
+              // Package not importable in Node context (browser-only) — return stub
+              // so that namespace loading succeeds and codegen can infer exported vars.
+              return {}
+            }
+          }
+        }
+        // Local/absolute path: may be a browser-only file (e.g. local .ts with DOM deps).
+        // Return a stub so the CLJ namespace still loads for server-side var inference.
+        try {
+          return await import(s)
+        } catch {
+          return {}
+        }
+      },
     })
     codegenCtx = {
-      session: serverSession,
       sourceRoots,
       coreIndexPath,
       virtualSessionId: VIRTUAL_SESSION_ID,
@@ -123,6 +173,32 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
     }
   }
 
+  function scanStringRequires() {
+    // original string (what CLJ runtime passes to importModule) → resolved path/pkg
+    const seen = new Map<string, string>()
+    for (const root of sourceRoots) {
+      const rootPath = resolve(projectRoot, root)
+      for (const filePath of collectCljFiles(rootPath)) {
+        try {
+          const source = readFileSync(filePath, 'utf-8')
+          // Call twice: without filePath to get original CLJ source strings,
+          // with filePath to get resolved absolute paths for relative specifiers.
+          const originals = extractStringRequires(source)
+          const resolved = extractStringRequires(source, filePath)
+          for (let i = 0; i < originals.length; i++) {
+            seen.set(originals[i], resolved[i])
+          }
+        } catch {
+          continue
+        }
+      }
+    }
+    stringRequires = [...seen.entries()].map(([original, resolved]) => ({
+      original,
+      resolved,
+    }))
+  }
+
   function regenerateBuiltInNamespaceSources() {
     try {
       statSync(generatorScriptPath)
@@ -142,6 +218,23 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
     }
   }
 
+  /**
+   * Generate the static import table lines for the virtual session module.
+   * Each specifier gets a unique variable name. Returns { importLines, mapEntries }.
+   */
+  function buildImportTable(): { importLines: string[]; mapEntries: string[] } {
+    const importLines: string[] = []
+    const mapEntries: string[] = []
+    stringRequires.forEach(({ original, resolved }, i) => {
+      const varName = `_imp_${i}`
+      // Import statement uses the resolved path (absolute for local files, pkg name for packages).
+      // Map key uses the original CLJ source string — this is what importModule(s) receives at runtime.
+      importLines.push(`import * as ${varName} from ${JSON.stringify(resolved)};`)
+      mapEntries.push(`  ${JSON.stringify(original)}: ${varName},`)
+    })
+    return { importLines, mapEntries }
+  }
+
   return {
     name: 'vite-plugin-clj',
 
@@ -152,6 +245,22 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
       regenerateBuiltInNamespaceSources()
       coreIndexPath = resolveCoreIndexPath()
       initServerSession()
+
+      // Detect Mode 2: explicit user entrypoint
+      if (options?.entrypoint) {
+        const ep = resolve(projectRoot, options.entrypoint)
+        try {
+          statSync(ep)
+          entrypointPath = ep
+        } catch {
+          // Configured entrypoint doesn't exist — fall through to Mode 1 with a warning
+          console.warn(
+            `[vite-plugin-clj] entrypoint not found: ${options.entrypoint} — falling back to auto-generated session`
+          )
+        }
+      }
+
+      scanStringRequires()
       eagerlyGenerateDts()
     },
 
@@ -176,42 +285,88 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
 
     load(id: string) {
       if (id === RESOLVED_VIRTUAL_SESSION_ID) {
-        const lines = [
+        const { importLines, mapEntries } = buildImportTable()
+
+        // All static imports must be at the top of the module (ESM hoist semantics)
+        const lines: string[] = [
           `import { createSession, printString } from ${JSON.stringify(coreIndexPath)};`,
+          ...importLines,
+          ...(entrypointPath
+            ? [`import __conjureFactory from ${JSON.stringify(entrypointPath)};`]
+            : []),
+          ``,
+          `const __importMap = {`,
+          ...mapEntries,
+          `};`,
           ``,
           `let _session = null;`,
-          `export function getSession() {`,
-          `  if (!_session) {`,
-          `    _session = createSession();`,
-          `  }`,
-          `  return _session;`,
-          `}`,
+          `let _outputLines = [];`,
         ]
 
+        if (entrypointPath) {
+          // Mode 2: user-defined factory returns SessionOptions (without output/importModule).
+          // The plugin owns output capture (for nREPL relay) and importModule (import map wiring).
+          // User factory controls hostBindings, modules, entries, etc.
+          lines.push(
+            `export function getSession() {`,
+            `  if (!_session) {`,
+            `    const __userOpts = __conjureFactory(__importMap) ?? {};`,
+            `    _session = createSession({`,
+            `      ...(__userOpts),`,
+            `      importModule: (s) => __importMap[s],`,
+            `      output: (text) => { _outputLines.push(text); console.log(text.replace(/\\n$/, '')); },`,
+            `    });`,
+            `  }`,
+            `  return _session;`,
+            `}`,
+          )
+        } else {
+          // Mode 1: auto-generate session with import map wired in
+          lines.push(
+            `export function getSession() {`,
+            `  if (!_session) {`,
+            `    _session = createSession({`,
+            `      importModule: (s) => __importMap[s],`,
+            `      output: (text) => { _outputLines.push(text); console.log(text.replace(/\\n$/, '')); },`,
+            `    });`,
+            `  }`,
+            `  return _session;`,
+            `}`,
+          )
+        }
+
         if (serveMode) {
           lines.push(
             ``,
             `// Browser nREPL relay — active only in Vite dev server`,
             `if (import.meta.hot) {`,
-            `  import.meta.hot.on('conjure:eval', ({ id, code, ns }) => {`,
+            `  import.meta.hot.on('conjure:eval', async ({ id, code, ns }) => {`,
             `    const session = getSession();`,
+            `    _outputLines = [];`,
             `    try {`,
             `      if (ns && ns !== session.currentNs) session.setNs(ns);`,
-            `      const result = session.evaluate(code);`,
-            `      import.meta.hot.send('conjure:eval-result', { id, value: printString(result), ns: session.currentNs });`,
+            `      const result = await session.evaluateAsync(code);`,
+            `      const out = _outputLines.join('');`,
+            `      import.meta.hot.send('conjure:eval-result', { id, value: printString(result), ns: session.currentNs, ...(out ? { out } : {}) });`,
             `    } catch (err) {`,
-            `      import.meta.hot.send('conjure:eval-result', { id, error: err instanceof Error ? err.message : String(err), ns: session.currentNs });`,
+            `      console.error(err);`,
+            `      const out = _outputLines.join('');`,
+            `      import.meta.hot.send('conjure:eval-result', { id, error: err instanceof Error ? err.message : String(err), ns: session.currentNs, ...(out ? { out } : {}) });`,
             `    }`,
             `  });`,
             ``,
-            `  import.meta.hot.on('conjure:load-file', ({ id, source, nsHint, filePath }) => {`,
+            `  import.meta.hot.on('conjure:load-file', async ({ id, source, nsHint, filePath }) => {`,
             `    const session = getSession();`,
+            `    _outputLines = [];`,
             `    try {`,
-            `      const loadedNs = session.loadFile(source, nsHint, filePath || undefined);`,
+            `      const loadedNs = await session.loadFileAsync(source, nsHint, filePath || undefined);`,
             `      if (loadedNs) session.setNs(loadedNs);`,
-            `      import.meta.hot.send('conjure:load-file-result', { id, value: 'nil', ns: session.currentNs });`,
+            `      const out = _outputLines.join('');`,
+            `      import.meta.hot.send('conjure:load-file-result', { id, value: 'nil', ns: session.currentNs, ...(out ? { out } : {}) });`,
             `    } catch (err) {`,
-            `      import.meta.hot.send('conjure:load-file-result', { id, error: err instanceof Error ? err.message : String(err), ns: session.currentNs });`,
+            `      console.error(err);`,
+            `      const out = _outputLines.join('');`,
+            `      import.meta.hot.send('conjure:load-file-result', { id, error: err instanceof Error ? err.message : String(err), ns: session.currentNs, ...(out ? { out } : {}) });`,
             `    }`,
             `  });`,
             `}`,
@@ -224,9 +379,9 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
       if (id.endsWith('.clj') && !id.includes('?')) {
         const source = readFileSync(id, 'utf-8')
         const nsNameFromPath = pathToNs(relative(projectRoot, id), sourceRoots)
-        const code = generateModuleCode(codegenCtx, nsNameFromPath, source)
+        const code = generateModuleCode(codegenCtx, nsNameFromPath, source, id)
         const dts = generateDts(codegenCtx, nsNameFromPath, source)
-        writeFileIfChanged(id + '.d.ts', dts)
+        if (dts) writeFileIfChanged(id + '.d.ts', dts)
         return code
       }
     },
@@ -241,7 +396,7 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
         const source = await read()
         try {
           const nsNameFromPath = pathToNs(relative(projectRoot, file), sourceRoots)
-          serverSession.loadFile(source, nsNameFromPath)
+          await serverSession.loadFileAsync(source, nsNameFromPath)
           const dts = generateDts(codegenCtx, nsNameFromPath, source)
           writeFileIfChanged(file + '.d.ts', dts)
         } catch {

package/src/vite-plugin-clj/namespace-utils.ts

@@ -1,3 +1,4 @@
+import { resolve, dirname } from 'node:path'
 import { isKeyword, isList, isSymbol, isVector } from '../core/assertions'
 import { readForms } from '../core/reader'
 import { tokenize } from '../core/tokenizer'
@@ -63,6 +64,44 @@ export function extractNsRequires(source: string): string[] {
   return requires
 }
 
+/**
+ * Parse Clojure source and extract all string module specifiers from (:require ...) clauses.
+ * These are the JS/npm imports written as string literals: (:require ["react" :as React]).
+ * Returns an array of resolved specifier strings (deduplicated).
+ *
+ * If filePath is provided, relative specifiers (starting with ./ or ../) are resolved
+ * to absolute paths using the file's directory. Package specifiers are returned as-is.
+ */
+export function extractStringRequires(source: string, filePath?: string): string[] {
+  const forms = readForms(tokenize(source))
+  const nsForm = forms.find(
+    (f) => isList(f) && isSymbol(f.value[0]) && f.value[0].name === 'ns'
+  )
+  if (!nsForm || !isList(nsForm)) return []
+
+  const specifiers: string[] = []
+  for (let i = 2; i < nsForm.value.length; i++) {
+    const clause = nsForm.value[i]
+    if (
+      isList(clause) &&
+      isKeyword(clause.value[0]) &&
+      clause.value[0].name === ':require'
+    ) {
+      for (let j = 1; j < clause.value.length; j++) {
+        const spec = clause.value[j]
+        const first = isVector(spec) && spec.value.length > 0 ? spec.value[0] : null
+        if (!first || first.kind !== 'string') continue
+        let specifier = first.value
+        if (filePath && (specifier.startsWith('./') || specifier.startsWith('../'))) {
+          specifier = resolve(dirname(filePath), specifier)
+        }
+        specifiers.push(specifier)
+      }
+    }
+  }
+  return [...new Set(specifiers)]
+}
+
 /**
  * Extract the namespace name from the (ns ...) form in a Clojure source string.
  * Returns null if no ns form is found.