conjure-js 0.0.12 → 0.0.13

package/src/core/bootstrap.ts

@@ -0,0 +1,337 @@
+import { isNamespace, isSymbol } from './assertions'
+import { internVar, makeNamespace, tryLookup } from './env'
+import { EvaluationError } from './errors'
+import { v } from './factories'
+import type { CljNamespace, CljValue, Env, EvaluationContext } from './types'
+import { ensureNamespaceInRegistry, processRequireSpec } from './registry'
+import type { NamespaceRegistry } from './registry'
+
+// ---------------------------------------------------------------------------
+// wireNsCore — wires *ns*, namespace introspection fns, require, and resolve
+// into coreEnv. Called from buildRuntime with explicit parameters instead of
+// relying on shared closure state.
+// ---------------------------------------------------------------------------
+
+export function wireNsCore(
+  registry: NamespaceRegistry,
+  coreEnv: Env,
+  getCurrentNs: () => string,
+  resolveNamespace: (nsName: string, ctx: EvaluationContext) => boolean
+): void {
+  // *ns* var — holds the current namespace as a CljNamespace value
+  const initialNsObj = registry.get('user')?.ns ?? makeNamespace('user')
+  internVar('*ns*', initialNsObj, coreEnv)
+  const nsVar = coreEnv.ns?.vars.get('*ns*')
+  if (nsVar) nsVar.dynamic = true
+
+  // Helper: resolve a namespace symbol (or namespace object) to its CljNamespace
+  function resolveNsSym(sym: CljValue): CljNamespace | null {
+    if (sym === undefined) return null
+    if (isNamespace(sym)) return sym
+    if (!isSymbol(sym)) return null
+    return registry.get(sym.name)?.ns ?? null
+  }
+
+  // Namespace introspection
+  internVar(
+    'ns-name',
+    v.nativeFn('ns-name', (x: CljValue) => {
+      if (x === undefined) return v.nil()
+      if (x.kind === 'namespace') return v.symbol(x.name)
+      if (x.kind === 'symbol') return x
+      if (x.kind === 'string') return v.symbol(x.value)
+      return v.nil()
+    }),
+    coreEnv
+  )
+
+  internVar(
+    'all-ns',
+    v.nativeFn('all-ns', () =>
+      v.list([...registry.values()].map((env) => env.ns!).filter(Boolean))
+    ),
+    coreEnv
+  )
+
+  internVar(
+    'find-ns',
+    v.nativeFn('find-ns', (sym: CljValue) => {
+      if (sym === undefined || !isSymbol(sym)) return v.nil()
+      return registry.get(sym.name)?.ns ?? v.nil()
+    }),
+    coreEnv
+  )
+
+  internVar(
+    'in-ns',
+    v.nativeFnCtx('in-ns', (ctx, _callEnv, sym: CljValue) => {
+      if (!sym || !isSymbol(sym)) {
+        throw new EvaluationError('in-ns expects a symbol', { sym })
+      }
+      if (ctx.setCurrentNs) ctx.setCurrentNs(sym.name)
+      return registry.get(sym.name)?.ns ?? v.nil()
+    }),
+    coreEnv
+  )
+
+  internVar(
+    'ns-aliases',
+    v.nativeFn('ns-aliases', (sym: CljValue) => {
+      const ns = resolveNsSym(sym)
+      if (!ns) return v.map([])
+      const entries: [CljValue, CljValue][] = []
+      ns.aliases.forEach((targetNs, alias) => {
+        entries.push([v.symbol(alias), targetNs])
+      })
+      return v.map(entries)
+    }),
+    coreEnv
+  )
+
+  internVar(
+    'ns-interns',
+    v.nativeFn('ns-interns', (sym: CljValue) => {
+      const ns = resolveNsSym(sym)
+      if (!ns) return v.map([])
+      const entries: [CljValue, CljValue][] = []
+      ns.vars.forEach((theVar, name) => {
+        if (theVar.ns === ns.name) entries.push([v.symbol(name), theVar])
+      })
+      return v.map(entries)
+    }),
+    coreEnv
+  )
+
+  internVar(
+    'ns-publics',
+    v.nativeFn('ns-publics', (sym: CljValue) => {
+      const ns = resolveNsSym(sym)
+      if (!ns) return v.map([])
+      const entries: [CljValue, CljValue][] = []
+      ns.vars.forEach((theVar, name) => {
+        if (theVar.ns !== ns.name) return
+        const isPrivate = (theVar.meta?.entries ?? []).some(
+          ([k, val]) =>
+            k.kind === 'keyword' && k.name === ':private' &&
+            val.kind === 'boolean' && val.value === true
+        )
+        if (!isPrivate) entries.push([v.symbol(name), theVar])
+      })
+      return v.map(entries)
+    }),
+    coreEnv
+  )
+
+  internVar(
+    'ns-refers',
+    v.nativeFn('ns-refers', (sym: CljValue) => {
+      const ns = resolveNsSym(sym)
+      if (!ns) return v.map([])
+      const entries: [CljValue, CljValue][] = []
+      ns.vars.forEach((theVar, name) => {
+        if (theVar.ns !== ns.name) entries.push([v.symbol(name), theVar])
+      })
+      return v.map(entries)
+    }),
+    coreEnv
+  )
+
+  internVar(
+    'ns-map',
+    v.nativeFn('ns-map', (sym: CljValue) => {
+      const ns = resolveNsSym(sym)
+      if (!ns) return v.map([])
+      const entries: [CljValue, CljValue][] = []
+      ns.vars.forEach((theVar, name) => {
+        entries.push([v.symbol(name), theVar])
+      })
+      return v.map(entries)
+    }),
+    coreEnv
+  )
+
+  internVar(
+    'ns-imports',
+    v.nativeFn('ns-imports', (_sym: CljValue) => v.map([])),
+    coreEnv
+  )
+
+  internVar(
+    'the-ns',
+    v.nativeFn('the-ns', (sym: CljValue) => {
+      if (sym === undefined) return v.nil()
+      if (isNamespace(sym)) return sym
+      if (!isSymbol(sym)) return v.nil()
+      return registry.get(sym.name)?.ns ?? v.nil()
+    }),
+    coreEnv
+  )
+
+  internVar(
+    'instance?',
+    v.nativeFn('instance?', (_cls: CljValue, _obj: CljValue) =>
+      v.boolean(false)
+    ),
+    coreEnv
+  )
+
+  internVar(
+    'class',
+    v.nativeFn('class', (x: CljValue) => {
+      if (x === undefined) return v.nil()
+      return v.string(`conjure.${x.kind}`)
+    }),
+    coreEnv
+  )
+
+  internVar(
+    'class?',
+    v.nativeFn('class?', (_x: CljValue) => v.boolean(false)),
+    coreEnv
+  )
+
+  internVar(
+    'special-symbol?',
+    v.nativeFn('special-symbol?', (sym: CljValue) => {
+      if (sym === undefined || !isSymbol(sym)) return v.boolean(false)
+      const specials = new Set([
+        'def',
+        'if',
+        'do',
+        'let',
+        'quote',
+        'var',
+        'fn',
+        'loop',
+        'recur',
+        'throw',
+        'try',
+        'catch',
+        'finally',
+        'ns',
+        'defmacro',
+        'binding',
+        'monitor-enter',
+        'monitor-exit',
+        'new',
+        'set!',
+        '.',
+        'import',
+      ])
+      return v.boolean(specials.has(sym.name))
+    }),
+    coreEnv
+  )
+
+  internVar(
+    'loaded-libs',
+    v.nativeFn('loaded-libs', () => v.set([...registry.keys()].map(v.symbol))),
+    coreEnv
+  )
+
+  // require — context-aware so it can thread ctx to resolveNamespace
+  internVar(
+    'require',
+    v.nativeFnCtx('require', (ctx, _callEnv, ...args: CljValue[]) => {
+      const currentEnv = registry.get(getCurrentNs())!
+      for (const arg of args) {
+        processRequireSpec(arg, currentEnv, registry, (nsName) =>
+          resolveNamespace(nsName, ctx)
+        )
+      }
+      return v.nil()
+    }),
+    coreEnv
+  )
+
+  internVar(
+    'resolve',
+    v.nativeFn('resolve', (sym: CljValue) => {
+      if (!isSymbol(sym)) return v.nil()
+      const slashIdx = sym.name.indexOf('/')
+      if (slashIdx > 0) {
+        const nsName = sym.name.slice(0, slashIdx)
+        const symName = sym.name.slice(slashIdx + 1)
+        const nsEnv = registry.get(nsName) ?? null
+        if (!nsEnv) return v.nil()
+        return tryLookup(symName, nsEnv) ?? v.nil()
+      }
+      const currentEnv = registry.get(getCurrentNs())!
+      return tryLookup(sym.name, currentEnv) ?? v.nil()
+    }),
+    coreEnv
+  )
+}
+
+// ---------------------------------------------------------------------------
+// wireIdeStubs — wires clojure.reflect, cursive.repl.runtime, and Java class
+// stubs into the registry. These are no-op shims for IDE compatibility.
+// ---------------------------------------------------------------------------
+
+export function wireIdeStubs(registry: NamespaceRegistry, coreEnv: Env): void {
+  // IDE stubs: clojure.reflect
+  const reflectEnv = ensureNamespaceInRegistry(
+    registry,
+    coreEnv,
+    'clojure.reflect'
+  )
+  internVar(
+    'parse-flags',
+    v.nativeFn('parse-flags', (_flags: CljValue, _kind: CljValue) => v.set([])),
+    reflectEnv
+  )
+  internVar(
+    'reflect',
+    v.nativeFn('reflect', (_obj: CljValue) => v.map([])),
+    reflectEnv
+  )
+  internVar(
+    'type-reflect',
+    v.nativeFn('type-reflect', (_typeobj: CljValue, ..._opts: CljValue[]) =>
+      v.map([])
+    ),
+    reflectEnv
+  )
+
+  // IDE stubs: cursive.repl.runtime
+  const cursiveEnv = ensureNamespaceInRegistry(
+    registry,
+    coreEnv,
+    'cursive.repl.runtime'
+  )
+  internVar(
+    'completions',
+    v.nativeFn('completions', (..._args: CljValue[]) => v.nil()),
+    cursiveEnv
+  )
+
+  // Java class stubs — Cursive references these as bare symbols for type checks
+  for (const javaClass of [
+    'Class',
+    'Object',
+    'String',
+    'Number',
+    'Boolean',
+    'Integer',
+    'Long',
+    'Double',
+    'Float',
+    'Byte',
+    'Short',
+    'Character',
+    'Void',
+    'Math',
+    'System',
+    'Runtime',
+    'Thread',
+    'Throwable',
+    'Exception',
+    'Error',
+    'Iterable',
+    'Comparable',
+    'Runnable',
+    'Cloneable',
+  ]) {
+    internVar(javaClass, v.keyword(`:java.lang/${javaClass}`), coreEnv)
+  }
+}

package/src/core/conversions.ts

@@ -1,15 +1,5 @@
 import { isCljValue } from './assertions'
-import { applyFunction } from './evaluator'
-import {
-  cljBoolean,
-  cljKeyword,
-  cljMap,
-  cljNativeFunction,
-  cljNil,
-  cljNumber,
-  cljString,
-  cljVector,
-} from './factories'
+import { v } from './factories'
 import type { CljValue } from './types'
 
 export class ConversionError extends Error {
@@ -21,9 +11,25 @@ export class ConversionError extends Error {
   }
 }
 
+export type FunctionApplier = {
+  applyFunction: (fn: CljValue, args: CljValue[]) => CljValue
+}
+
 const richKeyKinds = new Set(['list', 'vector', 'map'])
 
-export function cljToJs(value: CljValue): unknown {
+// Used inside jsToClj's function wrapper when converting CLJ args back to JS.
+// CLJ args passed to JS-wrapped functions are almost always data values, so
+// no applier is needed. If a CLJ function is encountered here, we throw a clear
+// error — use session.cljToJs() for function-bearing values.
+const _throwingApplier: FunctionApplier = {
+  applyFunction: () => {
+    throw new ConversionError(
+      'Cannot convert a CLJ function to JS in this context — use session.cljToJs() instead.'
+    )
+  },
+}
+
+export function cljToJs(value: CljValue, applier: FunctionApplier): unknown {
   switch (value.kind) {
     case 'number':
       return value.value
@@ -39,18 +45,18 @@ export function cljToJs(value: CljValue): unknown {
       return value.name
     case 'list':
     case 'vector':
-      return value.value.map(cljToJs)
+      return value.value.map((item) => cljToJs(item, applier))
     case 'map': {
       const obj: Record<string, unknown> = {}
-      for (const [k, v] of value.entries) {
+      for (const [k, val] of value.entries) {
         if (richKeyKinds.has(k.kind)) {
           throw new ConversionError(
             `Rich key types (${k.kind}) are not supported in JS object conversion. Restructure your map to use string, keyword, or number keys.`,
-            { key: k, value: v }
+            { key: k, value: val }
           )
         }
-        const jsKey = String(cljToJs(k))
-        obj[jsKey] = cljToJs(v)
+        const jsKey = String(cljToJs(k, applier))
+        obj[jsKey] = cljToJs(val, applier)
       }
       return obj
     }
@@ -58,9 +64,9 @@ export function cljToJs(value: CljValue): unknown {
     case 'native-function': {
       const fn = value
       return (...jsArgs: unknown[]) => {
-        const cljArgs = jsArgs.map(jsToClj)
-        const result = applyFunction(fn, cljArgs)
-        return cljToJs(result)
+        const cljArgs = jsArgs.map((a) => jsToClj(a))
+        const result = applier.applyFunction(fn, cljArgs)
+        return cljToJs(result, applier)
       }
     }
     case 'macro':
@@ -71,33 +77,44 @@ export function cljToJs(value: CljValue): unknown {
   }
 }
 
-export function jsToClj(value: unknown): CljValue {
-  if (value === null || value === undefined) return cljNil()
+export interface JsToCljOpts {
+  /** When true, plain object keys become keywords. Default: true. */
+  keywordizeKeys?: boolean
+}
+
+export function jsToClj(value: unknown, opts: JsToCljOpts = {}): CljValue {
+  const { keywordizeKeys = true } = opts
+
+  if (value === null) return v.nil()
+  if (value === undefined) return v.jsValue(undefined)
   if (isCljValue(value)) return value
 
   switch (typeof value) {
     case 'number':
-      return cljNumber(value)
+      return v.number(value)
     case 'string':
-      return cljString(value)
+      return v.string(value)
     case 'boolean':
-      return cljBoolean(value)
+      return v.boolean(value)
     case 'function': {
       const jsFn = value as (...args: unknown[]) => unknown
-      return cljNativeFunction('js-fn', (...cljArgs: CljValue[]) => {
-        const jsArgs = cljArgs.map(cljToJs)
+      return v.nativeFn('js-fn', (...cljArgs: CljValue[]) => {
+        const jsArgs = cljArgs.map((a) => cljToJs(a, _throwingApplier))
         const result = jsFn(...jsArgs)
-        return jsToClj(result)
+        return jsToClj(result, opts)
       })
     }
     case 'object': {
       if (Array.isArray(value)) {
-        return cljVector(value.map(jsToClj))
+        return v.vector(value.map((item) => jsToClj(item, opts)))
       }
       const entries: [CljValue, CljValue][] = Object.entries(
         value as Record<string, unknown>
-      ).map(([k, v]) => [cljKeyword(`:${k}`), jsToClj(v)])
-      return cljMap(entries)
+      ).map(([k, val]) => [
+        keywordizeKeys ? v.keyword(`:${k}`) : v.string(k),
+        jsToClj(val, opts),
+      ])
+      return v.map(entries)
     }
     default:
       throw new ConversionError(