conjure-js 0.0.1

package/src/clojure/generated/clojure-string-source.ts

@@ -0,0 +1,196 @@
+// Auto-generated from src/clojure/string.clj — do not edit directly.
+// Re-generate with: npm run gen:core-source
+export const clojure_stringSource = `\
+(ns clojure.string)
+
+;; Runtime-injected native helpers. Declared here so clojure-lsp can resolve
+;; them; the interpreter treats bare (def name) as a no-op and leaves the
+;; native binding from coreEnv intact.
+(def str-split*)
+(def str-upper-case*)
+(def str-lower-case*)
+(def str-trim*)
+(def str-triml*)
+(def str-trimr*)
+(def str-reverse*)
+(def str-starts-with*)
+(def str-ends-with*)
+(def str-includes*)
+(def str-index-of*)
+(def str-last-index-of*)
+(def str-replace*)
+(def str-replace-first*)
+
+;; ---------------------------------------------------------------------------
+;; Joining / splitting
+;; ---------------------------------------------------------------------------
+
+(defn join
+  "Returns a string of all elements in coll, as returned by (str), separated
+  by an optional separator."
+  ([coll] (join "" coll))
+  ([separator coll]
+   (if (nil? coll)
+     ""
+     (reduce
+      (fn [acc x]
+        (if (= acc "")
+          (str x)
+          (str acc separator x)))
+      ""
+      coll))))
+
+(defn split
+  "Splits string on a regular expression. Optional limit is the maximum number
+  of parts returned. Trailing empty strings are not returned by default; pass
+  a limit of -1 to return all."
+  ([s sep] (str-split* s sep))
+  ([s sep limit] (str-split* s sep limit)))
+
+(defn split-lines
+  "Splits s on \\\\n or \\\\r\\\\n. Trailing empty lines are not returned."
+  [s]
+  (split s #"\\r?\\n"))
+
+;; ---------------------------------------------------------------------------
+;; Case conversion
+;; ---------------------------------------------------------------------------
+
+(defn upper-case
+  "Converts string to all upper-case."
+  [s]
+  (str-upper-case* s))
+
+(defn lower-case
+  "Converts string to all lower-case."
+  [s]
+  (str-lower-case* s))
+
+(defn capitalize
+  "Converts first character of the string to upper-case, all other
+  characters to lower-case."
+  [s]
+  (if (< (count s) 2)
+    (upper-case s)
+    (str (upper-case (subs s 0 1)) (lower-case (subs s 1)))))
+
+;; ---------------------------------------------------------------------------
+;; Trimming
+;; ---------------------------------------------------------------------------
+
+(defn trim
+  "Removes whitespace from both ends of string."
+  [s]
+  (str-trim* s))
+
+(defn triml
+  "Removes whitespace from the left side of string."
+  [s]
+  (str-triml* s))
+
+(defn trimr
+  "Removes whitespace from the right side of string."
+  [s]
+  (str-trimr* s))
+
+(defn trim-newline
+  "Removes all trailing newline \\\\n or return \\\\r characters from string.
+  Similar to Perl's chomp."
+  [s]
+  (replace s #"[\\r\\n]+$" ""))
+
+;; ---------------------------------------------------------------------------
+;; Predicates
+;; ---------------------------------------------------------------------------
+
+(defn blank?
+  "True if s is nil, empty, or contains only whitespace."
+  [s]
+  (or (nil? s) (not (nil? (re-matches #"\\s*" s)))))
+
+(defn starts-with?
+  "True if s starts with substr."
+  [s substr]
+  (str-starts-with* s substr))
+
+(defn ends-with?
+  "True if s ends with substr."
+  [s substr]
+  (str-ends-with* s substr))
+
+(defn includes?
+  "True if s includes substr."
+  [s substr]
+  (str-includes* s substr))
+
+;; ---------------------------------------------------------------------------
+;; Search
+;; ---------------------------------------------------------------------------
+
+(defn index-of
+  "Return index of value (string) in s, optionally searching forward from
+  from-index. Return nil if value not found."
+  ([s value] (str-index-of* s value))
+  ([s value from-index] (str-index-of* s value from-index)))
+
+(defn last-index-of
+  "Return last index of value (string) in s, optionally searching backward
+  from from-index. Return nil if value not found."
+  ([s value] (str-last-index-of* s value))
+  ([s value from-index] (str-last-index-of* s value from-index)))
+
+;; ---------------------------------------------------------------------------
+;; Replacement
+;; ---------------------------------------------------------------------------
+
+(defn replace
+  "Replaces all instances of match with replacement in s.
+
+  match/replacement can be:
+    string / string   — literal match, literal replacement
+    pattern / string  — regex match; $1, $2, etc. substituted from groups
+    pattern / fn      — regex match; fn called with match (string or vector
+                        of [whole g1 g2 ...]), return value used as replacement.
+
+  See also replace-first."
+  [s match replacement]
+  (str-replace* s match replacement))
+
+(defn replace-first
+  "Replaces the first instance of match with replacement in s.
+  Same match/replacement semantics as replace."
+  [s match replacement]
+  (str-replace-first* s match replacement))
+
+(defn re-quote-replacement
+  "Given a replacement string that you wish to be a literal replacement for a
+  pattern match in replace or replace-first, escape any special replacement
+  characters ($ signs) so they are treated literally."
+  [s]
+  (replace s #"\\$" "$$$$"))
+
+;; ---------------------------------------------------------------------------
+;; Miscellaneous
+;; ---------------------------------------------------------------------------
+
+(defn reverse
+  "Returns s with its characters reversed."
+  [s]
+  (str-reverse* s))
+
+(defn escape
+  "Return a new string, using cmap to escape each character ch from s as
+  follows: if (cmap ch) is nil, append ch to the new string; otherwise append
+  (str (cmap ch)).
+
+  cmap may be a map or a function. Maps are callable directly (IFn semantics).
+
+  Note: Clojure uses char literal keys (e.g. {\\\\< \\"&lt;\\"}). This interpreter
+  has no char type, so map keys must be single-character strings instead
+  (e.g. {\\"<\\" \\"&lt;\\"})."
+  [s cmap]
+  (apply str (map (fn [c]
+                    (let [r (cmap c)]
+                      (if (nil? r) c (str r))))
+                  (split s #""))))
+`

package/src/clojure/string.clj

@@ -0,0 +1,192 @@
+(ns clojure.string)
+
+;; Runtime-injected native helpers. Declared here so clojure-lsp can resolve
+;; them; the interpreter treats bare (def name) as a no-op and leaves the
+;; native binding from coreEnv intact.
+(def str-split*)
+(def str-upper-case*)
+(def str-lower-case*)
+(def str-trim*)
+(def str-triml*)
+(def str-trimr*)
+(def str-reverse*)
+(def str-starts-with*)
+(def str-ends-with*)
+(def str-includes*)
+(def str-index-of*)
+(def str-last-index-of*)
+(def str-replace*)
+(def str-replace-first*)
+
+;; ---------------------------------------------------------------------------
+;; Joining / splitting
+;; ---------------------------------------------------------------------------
+
+(defn join
+  "Returns a string of all elements in coll, as returned by (str), separated
+  by an optional separator."
+  ([coll] (join "" coll))
+  ([separator coll]
+   (if (nil? coll)
+     ""
+     (reduce
+      (fn [acc x]
+        (if (= acc "")
+          (str x)
+          (str acc separator x)))
+      ""
+      coll))))
+
+(defn split
+  "Splits string on a regular expression. Optional limit is the maximum number
+  of parts returned. Trailing empty strings are not returned by default; pass
+  a limit of -1 to return all."
+  ([s sep] (str-split* s sep))
+  ([s sep limit] (str-split* s sep limit)))
+
+(defn split-lines
+  "Splits s on \\n or \\r\\n. Trailing empty lines are not returned."
+  [s]
+  (split s #"\r?\n"))
+
+;; ---------------------------------------------------------------------------
+;; Case conversion
+;; ---------------------------------------------------------------------------
+
+(defn upper-case
+  "Converts string to all upper-case."
+  [s]
+  (str-upper-case* s))
+
+(defn lower-case
+  "Converts string to all lower-case."
+  [s]
+  (str-lower-case* s))
+
+(defn capitalize
+  "Converts first character of the string to upper-case, all other
+  characters to lower-case."
+  [s]
+  (if (< (count s) 2)
+    (upper-case s)
+    (str (upper-case (subs s 0 1)) (lower-case (subs s 1)))))
+
+;; ---------------------------------------------------------------------------
+;; Trimming
+;; ---------------------------------------------------------------------------
+
+(defn trim
+  "Removes whitespace from both ends of string."
+  [s]
+  (str-trim* s))
+
+(defn triml
+  "Removes whitespace from the left side of string."
+  [s]
+  (str-triml* s))
+
+(defn trimr
+  "Removes whitespace from the right side of string."
+  [s]
+  (str-trimr* s))
+
+(defn trim-newline
+  "Removes all trailing newline \\n or return \\r characters from string.
+  Similar to Perl's chomp."
+  [s]
+  (replace s #"[\r\n]+$" ""))
+
+;; ---------------------------------------------------------------------------
+;; Predicates
+;; ---------------------------------------------------------------------------
+
+(defn blank?
+  "True if s is nil, empty, or contains only whitespace."
+  [s]
+  (or (nil? s) (not (nil? (re-matches #"\s*" s)))))
+
+(defn starts-with?
+  "True if s starts with substr."
+  [s substr]
+  (str-starts-with* s substr))
+
+(defn ends-with?
+  "True if s ends with substr."
+  [s substr]
+  (str-ends-with* s substr))
+
+(defn includes?
+  "True if s includes substr."
+  [s substr]
+  (str-includes* s substr))
+
+;; ---------------------------------------------------------------------------
+;; Search
+;; ---------------------------------------------------------------------------
+
+(defn index-of
+  "Return index of value (string) in s, optionally searching forward from
+  from-index. Return nil if value not found."
+  ([s value] (str-index-of* s value))
+  ([s value from-index] (str-index-of* s value from-index)))
+
+(defn last-index-of
+  "Return last index of value (string) in s, optionally searching backward
+  from from-index. Return nil if value not found."
+  ([s value] (str-last-index-of* s value))
+  ([s value from-index] (str-last-index-of* s value from-index)))
+
+;; ---------------------------------------------------------------------------
+;; Replacement
+;; ---------------------------------------------------------------------------
+
+(defn replace
+  "Replaces all instances of match with replacement in s.
+
+  match/replacement can be:
+    string / string   — literal match, literal replacement
+    pattern / string  — regex match; $1, $2, etc. substituted from groups
+    pattern / fn      — regex match; fn called with match (string or vector
+                        of [whole g1 g2 ...]), return value used as replacement.
+
+  See also replace-first."
+  [s match replacement]
+  (str-replace* s match replacement))
+
+(defn replace-first
+  "Replaces the first instance of match with replacement in s.
+  Same match/replacement semantics as replace."
+  [s match replacement]
+  (str-replace-first* s match replacement))
+
+(defn re-quote-replacement
+  "Given a replacement string that you wish to be a literal replacement for a
+  pattern match in replace or replace-first, escape any special replacement
+  characters ($ signs) so they are treated literally."
+  [s]
+  (replace s #"\$" "$$$$"))
+
+;; ---------------------------------------------------------------------------
+;; Miscellaneous
+;; ---------------------------------------------------------------------------
+
+(defn reverse
+  "Returns s with its characters reversed."
+  [s]
+  (str-reverse* s))
+
+(defn escape
+  "Return a new string, using cmap to escape each character ch from s as
+  follows: if (cmap ch) is nil, append ch to the new string; otherwise append
+  (str (cmap ch)).
+
+  cmap may be a map or a function. Maps are callable directly (IFn semantics).
+
+  Note: Clojure uses char literal keys (e.g. {\\< \"&lt;\"}). This interpreter
+  has no char type, so map keys must be single-character strings instead
+  (e.g. {\"<\" \"&lt;\"})."
+  [s cmap]
+  (apply str (map (fn [c]
+                    (let [r (cmap c)]
+                      (if (nil? r) c (str r))))
+                  (split s #""))))

package/src/clojure/string.clj.d.ts

@@ -0,0 +1,25 @@
+export function join(coll: unknown): unknown;
+export function join(separator: unknown, coll: unknown): unknown;
+export function split(s: unknown, sep: unknown): unknown;
+export function split(s: unknown, sep: unknown, limit: unknown): unknown;
+export function split_lines(s: unknown): unknown;
+export function upper_case(s: unknown): unknown;
+export function lower_case(s: unknown): unknown;
+export function capitalize(s: unknown): unknown;
+export function trim(s: unknown): unknown;
+export function triml(s: unknown): unknown;
+export function trimr(s: unknown): unknown;
+export function trim_newline(s: unknown): unknown;
+export function blank_QMARK_(s: unknown): unknown;
+export function starts_with_QMARK_(s: unknown, substr: unknown): unknown;
+export function ends_with_QMARK_(s: unknown, substr: unknown): unknown;
+export function includes_QMARK_(s: unknown, substr: unknown): unknown;
+export function index_of(s: unknown, value: unknown): unknown;
+export function index_of(s: unknown, value: unknown, from_index: unknown): unknown;
+export function last_index_of(s: unknown, value: unknown): unknown;
+export function last_index_of(s: unknown, value: unknown, from_index: unknown): unknown;
+export function replace(s: unknown, match: unknown, replacement: unknown): unknown;
+export function replace_first(s: unknown, match: unknown, replacement: unknown): unknown;
+export function re_quote_replacement(s: unknown): unknown;
+export function reverse(s: unknown): unknown;
+export function escape(s: unknown, cmap: unknown): unknown;

package/src/core/assertions.ts

@@ -0,0 +1,134 @@
+import {
+  valueKeywords,
+  type CljAtom,
+  type CljBoolean,
+  type CljFunction,
+  type CljKeyword,
+  type CljList,
+  type CljMacro,
+  type CljMap,
+  type CljMultiMethod,
+  type CljNativeFunction,
+  type CljNumber,
+  type CljReduced,
+  type CljRegex,
+  type CljString,
+  type CljSymbol,
+  type CljValue,
+  type CljVector,
+  type CljVolatile,
+} from './types.ts'
+import { specialFormKeywords } from './evaluator/special-forms.ts'
+
+export const isNil = (value: CljValue): boolean => value.kind === 'nil'
+export const isFalsy = (value: CljValue): boolean => {
+  if (value.kind === 'nil') return true
+  if (value.kind === 'boolean') return !value.value
+  return false
+}
+export const isTruthy = (value: CljValue): boolean => {
+  return !isFalsy(value)
+}
+export const isSpecialForm = (
+  value: CljValue
+): value is CljSymbol & { name: keyof typeof specialFormKeywords } =>
+  value.kind === 'symbol' && value.name in specialFormKeywords
+export const isSymbol = (value: CljValue): value is CljSymbol =>
+  value.kind === 'symbol'
+export const isVector = (value: CljValue): value is CljVector =>
+  value.kind === 'vector'
+export const isList = (value: CljValue): value is CljList =>
+  value.kind === 'list'
+export const isFunction = (value: CljValue): value is CljFunction =>
+  value.kind === 'function'
+export const isNativeFunction = (value: CljValue): value is CljNativeFunction =>
+  value.kind === 'native-function'
+export const isMacro = (value: CljValue): value is CljMacro =>
+  value.kind === 'macro'
+export const isMap = (value: CljValue): value is CljMap => value.kind === 'map'
+export const isKeyword = (value: CljValue): value is CljKeyword =>
+  value.kind === 'keyword'
+export const isAFunction = (
+  value: CljValue
+): value is CljFunction | CljNativeFunction =>
+  isFunction(value) || isNativeFunction(value)
+
+/** True for any value that can be invoked like a function (IFn). */
+export const isCallable = (value: CljValue): boolean =>
+  isAFunction(value) || isKeyword(value) || isMap(value)
+export const isMultiMethod = (value: CljValue): value is CljMultiMethod =>
+  value.kind === 'multi-method'
+export const isAtom = (value: CljValue): value is CljAtom =>
+  value.kind === 'atom'
+export const isReduced = (value: CljValue): value is CljReduced =>
+  value.kind === 'reduced'
+export const isVolatile = (value: CljValue): value is CljVolatile =>
+  value.kind === 'volatile'
+export const isRegex = (value: CljValue): value is CljRegex =>
+  value.kind === 'regex'
+export const isCollection = (
+  value: CljValue
+): value is CljList | CljVector | CljMap =>
+  isVector(value) || isMap(value) || isList(value)
+
+export const isSeqable = (
+  value: CljValue
+): value is CljList | CljVector | CljMap | CljString =>
+  isCollection(value) || value.kind === 'string'
+
+export const isCljValue = (value: any): value is CljValue => {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'kind' in value &&
+    value.kind in valueKeywords
+  )
+}
+
+const equalityHandlers = {
+  [valueKeywords.number]: (a: CljNumber, b: CljNumber) => a.value === b.value,
+  [valueKeywords.string]: (a: CljString, b: CljString) => a.value === b.value,
+  [valueKeywords.boolean]: (a: CljBoolean, b: CljBoolean) =>
+    a.value === b.value,
+  [valueKeywords.nil]: () => true,
+  [valueKeywords.symbol]: (a: CljSymbol, b: CljSymbol) => a.name === b.name,
+  [valueKeywords.keyword]: (a: CljKeyword, b: CljKeyword) => a.name === b.name,
+  [valueKeywords.vector]: (a: CljVector, b: CljVector) => {
+    if (a.value.length !== b.value.length) return false
+    return a.value.every((value, index) => isEqual(value, b.value[index]))
+  },
+  [valueKeywords.map]: (a: CljMap, b: CljMap) => {
+    if (a.entries.length !== b.entries.length) return false
+    const uniqueKeys = new Set([
+      ...a.entries.map(([key]) => key),
+      ...b.entries.map(([key]) => key),
+    ])
+    for (const key of uniqueKeys) {
+      const aEntry = a.entries.find(([k]) => isEqual(k, key))
+      if (!aEntry) return false
+      const bEntry = b.entries.find(([k]) => isEqual(k, key))
+      if (!bEntry) return false
+      if (!isEqual(aEntry[1], bEntry[1])) return false
+    }
+    return true
+  },
+  [valueKeywords.list]: (a: CljList, b: CljList) => {
+    if (a.value.length !== b.value.length) return false
+    return a.value.every((value, index) => isEqual(value, b.value[index]))
+  },
+  [valueKeywords.atom]: (a: CljAtom, b: CljAtom) => a === b,
+  [valueKeywords.reduced]: (a: CljReduced, b: CljReduced) =>
+    isEqual(a.value, b.value),
+  [valueKeywords.volatile]: (a: CljVolatile, b: CljVolatile) => a === b,
+  // Regex uses reference equality matching Clojure Pattern semantics:
+  // (= #"foo" #"foo") => false — each literal is a distinct object
+  [valueKeywords.regex]: (a: CljRegex, b: CljRegex) => a === b,
+}
+
+export const isEqual = (a: CljValue, b: CljValue): boolean => {
+  if (a.kind !== b.kind) return false
+
+  const handler = equalityHandlers[a.kind as keyof typeof equalityHandlers]
+  if (!handler) return false
+  return handler(a as never, b as never)
+}

package/src/core/conversions.ts

@@ -0,0 +1,108 @@
+import { isCljValue } from './assertions'
+import { applyFunction } from './evaluator'
+import {
+  cljBoolean,
+  cljKeyword,
+  cljMap,
+  cljNativeFunction,
+  cljNil,
+  cljNumber,
+  cljString,
+  cljVector,
+} from './factories'
+import type { CljValue } from './types'
+
+export class ConversionError extends Error {
+  context: unknown
+  constructor(message: string, context?: unknown) {
+    super(message)
+    this.name = 'ConversionError'
+    this.context = context
+  }
+}
+
+const richKeyKinds = new Set(['list', 'vector', 'map'])
+
+export function cljToJs(value: CljValue): unknown {
+  switch (value.kind) {
+    case 'number':
+      return value.value
+    case 'string':
+      return value.value
+    case 'boolean':
+      return value.value
+    case 'nil':
+      return null
+    case 'keyword':
+      return value.name.startsWith(':') ? value.name.slice(1) : value.name
+    case 'symbol':
+      return value.name
+    case 'list':
+    case 'vector':
+      return value.value.map(cljToJs)
+    case 'map': {
+      const obj: Record<string, unknown> = {}
+      for (const [k, v] 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 }
+          )
+        }
+        const jsKey = String(cljToJs(k))
+        obj[jsKey] = cljToJs(v)
+      }
+      return obj
+    }
+    case 'function':
+    case 'native-function': {
+      const fn = value
+      return (...jsArgs: unknown[]) => {
+        const cljArgs = jsArgs.map(jsToClj)
+        const result = applyFunction(fn, cljArgs)
+        return cljToJs(result)
+      }
+    }
+    case 'macro':
+      throw new ConversionError(
+        'Macros cannot be exported to JavaScript. Macros are compile-time constructs.',
+        { macro: value }
+      )
+  }
+}
+
+export function jsToClj(value: unknown): CljValue {
+  if (value === null || value === undefined) return cljNil()
+  if (isCljValue(value)) return value
+
+  switch (typeof value) {
+    case 'number':
+      return cljNumber(value)
+    case 'string':
+      return cljString(value)
+    case 'boolean':
+      return cljBoolean(value)
+    case 'function': {
+      const jsFn = value as (...args: unknown[]) => unknown
+      return cljNativeFunction('js-fn', (...cljArgs: CljValue[]) => {
+        const jsArgs = cljArgs.map(cljToJs)
+        const result = jsFn(...jsArgs)
+        return jsToClj(result)
+      })
+    }
+    case 'object': {
+      if (Array.isArray(value)) {
+        return cljVector(value.map(jsToClj))
+      }
+      const entries: [CljValue, CljValue][] = Object.entries(
+        value as Record<string, unknown>
+      ).map(([k, v]) => [cljKeyword(`:${k}`), jsToClj(v)])
+      return cljMap(entries)
+    }
+    default:
+      throw new ConversionError(
+        `Cannot convert JS value of type ${typeof value} to CljValue`,
+        { value }
+      )
+  }
+}