conjure-js 0.0.1

package/src/core/types.ts

@@ -0,0 +1,258 @@
+export const valueKeywords = {
+  number: 'number',
+  string: 'string',
+  boolean: 'boolean',
+  keyword: 'keyword',
+  nil: 'nil',
+  symbol: 'symbol',
+  list: 'list',
+  vector: 'vector',
+  map: 'map',
+  function: 'function',
+  nativeFunction: 'native-function',
+  macro: 'macro',
+  multiMethod: 'multi-method',
+  atom: 'atom',
+  reduced: 'reduced',
+  volatile: 'volatile',
+  regex: 'regex',
+} as const
+export type ValueKeywords = (typeof valueKeywords)[keyof typeof valueKeywords]
+
+export type CljNumber = { kind: 'number'; value: number }
+export type CljString = { kind: 'string'; value: string }
+export type CljBoolean = { kind: 'boolean'; value: boolean }
+export type CljKeyword = { kind: 'keyword'; name: string }
+export type CljNil = { kind: 'nil'; value: null }
+export type CljSymbol = { kind: 'symbol'; name: string }
+export type CljList = { kind: 'list'; value: CljValue[] }
+export type CljVector = { kind: 'vector'; value: CljValue[] }
+export type CljMap = { kind: 'map'; entries: [CljValue, CljValue][] }
+export type Env = {
+  bindings: Map<string, CljValue>
+  outer: Env | null
+  namespace?: string // only present on namespace-root envs
+  aliases?: Map<string, Env> // only present on namespace-root envs; set by :as
+  readerAliases?: Map<string, string> // only present on namespace-root envs; set by :as-alias
+  resolveNs?: (name: string) => Env | null // only present on the root coreEnv
+}
+
+export type DestructurePattern = CljSymbol | CljVector | CljMap
+
+export type Arity = {
+  params: DestructurePattern[]
+  restParam: DestructurePattern | null
+  body: CljValue[]
+}
+
+export type CljFunction = {
+  kind: 'function'
+  arities: Arity[]
+  env: Env
+  meta?: CljMap
+}
+
+export type CljMacro = {
+  kind: 'macro'
+  arities: Arity[]
+  env: Env
+}
+
+export type CljAtom = { kind: 'atom'; value: CljValue }
+export type CljReduced = { kind: 'reduced'; value: CljValue }
+export type CljVolatile = { kind: 'volatile'; value: CljValue }
+export type CljRegex = { kind: 'regex'; pattern: string; flags: string }
+
+export type CljMultiMethod = {
+  kind: 'multi-method'
+  name: string
+  dispatchFn: CljFunction | CljNativeFunction
+  methods: Array<{ dispatchVal: CljValue; fn: CljFunction | CljNativeFunction }>
+  defaultMethod?: CljFunction | CljNativeFunction
+}
+
+export type EvaluationContext = {
+  evaluate: (expr: CljValue, env: Env) => CljValue
+  evaluateForms: (forms: CljValue[], env: Env) => CljValue
+  applyFunction: (
+    fn: CljFunction | CljNativeFunction,
+    args: CljValue[],
+    callEnv: Env
+  ) => CljValue
+  /** Invokes any IFn value: functions, native functions, keywords, and maps. */
+  applyCallable: (fn: CljValue, args: CljValue[], callEnv: Env) => CljValue
+  applyMacro: (macro: CljMacro, rawArgs: CljValue[]) => CljValue
+  expandAll: (form: CljValue, env: Env) => CljValue
+}
+
+export type CljNativeFunction = {
+  kind: 'native-function'
+  name: string
+  fn: (...args: CljValue[]) => CljValue
+  // Only used in case the function needs to access the evaluation context
+  fnWithContext?: (
+    ctx: EvaluationContext,
+    callEnv: Env,
+    ...args: CljValue[]
+  ) => CljValue
+  meta?: CljMap
+}
+
+export type CljValue =
+  | CljNumber
+  | CljString
+  | CljBoolean
+  | CljKeyword
+  | CljNil
+  | CljSymbol
+  | CljList
+  | CljVector
+  | CljMap
+  | CljFunction
+  | CljNativeFunction
+  | CljMacro
+  | CljMultiMethod
+  | CljAtom
+  | CljReduced
+  | CljVolatile
+  | CljRegex
+
+/** Tokens */
+export const tokenKeywords = {
+  LParen: 'LParen',
+  RParen: 'RParen',
+  LBracket: 'LBracket',
+  RBracket: 'RBracket',
+  LBrace: 'LBrace',
+  RBrace: 'RBrace',
+  String: 'String',
+  Number: 'Number',
+  Keyword: 'Keyword',
+  Quote: 'Quote',
+  Quasiquote: 'Quasiquote',
+  Unquote: 'Unquote',
+  UnquoteSplicing: 'UnquoteSplicing',
+  Comment: 'Comment',
+  Whitespace: 'Whitespace',
+  Symbol: 'Symbol',
+  AnonFnStart: 'AnonFnStart',
+  Deref: 'Deref',
+  Regex: 'Regex',
+} as const
+export const tokenSymbols = {
+  Quote: 'quote',
+  Quasiquote: 'quasiquote',
+  Unquote: 'unquote',
+  UnquoteSplicing: 'unquote-splicing',
+  LParen: '(',
+  RParen: ')',
+  LBracket: '[',
+  RBracket: ']',
+  LBrace: '{',
+  RBrace: '}',
+} as const
+export type TokenSymbols = (typeof tokenSymbols)[keyof typeof tokenSymbols]
+export type TokenKinds = keyof typeof tokenKeywords
+
+export type Cursor = {
+  line: number
+  col: number
+  offset: number
+}
+
+export type Pos = { start: number; end: number } // absolute char offsets into the source string
+
+export type TokenLParen = {
+  kind: 'LParen'
+  value: '('
+}
+export type TokenRParen = {
+  kind: 'RParen'
+  value: ')'
+}
+export type TokenLBracket = {
+  kind: 'LBracket'
+  value: '['
+}
+export type TokenRBracket = {
+  kind: 'RBracket'
+  value: ']'
+}
+export type TokenLBrace = {
+  kind: 'LBrace'
+  value: '{'
+}
+export type TokenRBrace = {
+  kind: 'RBrace'
+  value: '}'
+}
+export type TokenString = {
+  kind: 'String'
+  value: string
+}
+export type TokenNumber = {
+  kind: 'Number'
+  value: number
+}
+export type TokenKeyword = {
+  kind: 'Keyword'
+  value: string
+}
+export type TokenQuote = {
+  kind: 'Quote'
+  value: 'quote'
+}
+export type TokenComment = {
+  kind: 'Comment'
+  value: string
+}
+export type TokenWhitespace = {
+  kind: 'Whitespace'
+}
+export type TokenSymbol = {
+  kind: 'Symbol'
+  value: string
+}
+export type TokenQuasiquote = {
+  kind: 'Quasiquote'
+  value: 'quasiquote'
+}
+export type TokenUnquote = {
+  kind: 'Unquote'
+  value: 'unquote'
+}
+export type TokenUnquoteSplicing = {
+  kind: 'UnquoteSplicing'
+  value: 'unquote-splicing'
+}
+export type TokenAnonFnStart = {
+  kind: 'AnonFnStart'
+}
+export type TokenDeref = {
+  kind: 'Deref'
+}
+export type TokenRegex = {
+  kind: 'Regex'
+  value: string
+}
+export type Token = (
+  | TokenLParen
+  | TokenRParen
+  | TokenLBracket
+  | TokenRBracket
+  | TokenLBrace
+  | TokenRBrace
+  | TokenString
+  | TokenNumber
+  | TokenKeyword
+  | TokenQuote
+  | TokenComment
+  | TokenWhitespace
+  | TokenSymbol
+  | TokenQuasiquote
+  | TokenUnquote
+  | TokenUnquoteSplicing
+  | TokenAnonFnStart
+  | TokenDeref
+  | TokenRegex
+) & { start: Cursor; end: Cursor }

package/src/main.ts

@@ -0,0 +1 @@
+import './playground/playground'

package/src/monaco-esm.d.ts

@@ -0,0 +1,7 @@
+declare module 'monaco-editor/esm/vs/basic-languages/clojure/clojure' {
+  import type * as Monaco from 'monaco-editor'
+
+  export const language: Monaco.languages.IMonarchLanguage
+}
+
+declare module 'monaco-editor/esm/vs/editor/editor.worker'

package/src/playground/clojure-tokens.ts

@@ -0,0 +1,67 @@
+import { language as clojureLang } from 'monaco-editor/esm/vs/basic-languages/clojure/clojure'
+import type * as Monaco from 'monaco-editor'
+
+export const THEME_ID = 'vscode-clj-dark'
+
+/**
+ * Keep Monaco's native Clojure highlighting, but stop treating `(comment ...)`
+ * as a real comment block. In Clojure that form is a macro and its contents
+ * should still be tokenized as normal code.
+ */
+export function registerClojureLanguage(monaco: typeof Monaco): void {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const base = clojureLang as any
+
+  const filteredWhitespace = base.tokenizer.whitespace.filter(
+    // Monaco's built-in Clojure grammar marks `(comment ... )` as comment.
+    // We keep `;` comments, but drop this macro-specific rule.
+    (rule: unknown) =>
+      !(
+        Array.isArray(rule) &&
+        rule[0] instanceof RegExp &&
+        rule[1] === 'comment' &&
+        rule[0].source === '\\(comment\\b'
+      ),
+  )
+
+  monaco.languages.setMonarchTokensProvider('clojure', {
+    ...base,
+    tokenizer: {
+      ...base.tokenizer,
+      whitespace: filteredWhitespace,
+    },
+  })
+}
+
+/**
+ * Small VSCode-like theme override:
+ * - keep Monaco's default tokenization behavior
+ * - use neutral dark background/colors similar to VS Code Dark+
+ */
+export function defineMonacoTheme(monaco: typeof Monaco): void {
+  monaco.editor.defineTheme(THEME_ID, {
+    base: 'vs-dark',
+    inherit: true,
+    rules: [
+      { token: 'comment.clj', foreground: '6a9955' },
+      { token: 'string.clj', foreground: 'ce9178' },
+      { token: 'number.clj', foreground: 'b5cea8' },
+      { token: 'keyword.clj', foreground: 'c586c0' },
+      { token: 'constant.clj', foreground: '4fc1ff' },
+      { token: 'meta.clj', foreground: 'd7ba7d' },
+      { token: 'identifier.clj', foreground: 'd4d4d4' },
+    ],
+    colors: {
+      'editor.background': '#1e1e1e',
+      'editor.foreground': '#d4d4d4',
+      'editor.lineHighlightBackground': '#2a2d2e',
+      'editorCursor.foreground': '#aeafad',
+      'editor.selectionBackground': '#264f78',
+      'editor.inactiveSelectionBackground': '#3a3d41',
+      'editorLineNumber.foreground': '#858585',
+      'editorLineNumber.activeForeground': '#c6c6c6',
+      'editorBracketMatch.background': '#0064001a',
+      'editorBracketMatch.border': '#888888',
+    },
+  })
+}

package/src/playground/editor.worker.ts

@@ -0,0 +1,5 @@
+// Thin wrapper so Vite can bundle Monaco's editor worker via the
+// `new URL('./editor.worker.ts', import.meta.url)` pattern.
+// Vite only recognises the worker-bundling pattern for relative paths;
+// bare package specifiers inside new URL() are not resolved the same way.
+import 'monaco-editor/esm/vs/editor/editor.worker'

package/src/playground/find-form.ts

@@ -0,0 +1,138 @@
+import { tokenize } from '../core/tokenizer'
+
+export type FormRange = {
+  /** Inclusive start offset in the source string */
+  start: number
+  /** Exclusive end offset in the source string */
+  end: number
+}
+
+// AnonFnStart (#() consumes both # and (, so it opens a RParen-closed scope
+const OPEN = new Set(['LParen', 'LBracket', 'LBrace', 'AnonFnStart'])
+const CLOSE = new Set(['RParen', 'RBracket', 'RBrace'])
+const PREFIX = new Set(['Quote', 'Quasiquote', 'Unquote', 'UnquoteSplicing'])
+const SKIP = new Set(['Whitespace', 'Comment'])
+
+// ── Public API ────────────────────────────────────────────────────────────────
+
+/**
+ * Calva-style "form before cursor" heuristic.
+ *
+ * Scans backwards from the cursor offset to find the last **complete** form:
+ *
+ *   - If the last token before the cursor is a close bracket `)` `]` `}` →
+ *     walk backwards to find its matching open bracket. The whole balanced
+ *     expression is the form.
+ *   - If the last token is an atom (symbol, number, keyword, string, …) →
+ *     that atom is the form.
+ *   - Reader-macro prefixes (`'` `` ` `` `~` `~@`) immediately before the form
+ *     are included in the returned range.
+ *
+ * Returns null when the cursor is after an unmatched open bracket, in
+ * whitespace/comments with nothing before it, or if tokenization fails.
+ */
+export function findFormBeforeCursor(
+  source: string,
+  cursorOffset: number,
+): FormRange | null {
+  let tokens
+  try {
+    tokens = tokenize(source)
+  } catch {
+    // Full-source tokenization failed (e.g. unsupported syntax elsewhere in
+    // the file).  Retry with just the text up to the cursor — enough to find
+    // the form before it, and avoids any bad syntax that lives after it.
+    try {
+      tokens = tokenize(source.slice(0, cursorOffset))
+    } catch {
+      return null
+    }
+  }
+
+  // Relevant tokens: non-whitespace, non-comment, ending at or before cursor
+  const relevant = tokens.filter(
+    (t) => !SKIP.has(t.kind) && t.end.offset <= cursorOffset,
+  )
+
+  if (relevant.length === 0) return null
+
+  const lastIdx = relevant.length - 1
+  const last = relevant[lastIdx]
+
+  let range: FormRange
+
+  if (CLOSE.has(last.kind)) {
+    // Closing bracket — find its matching open
+    const openIdx = findMatchingOpen(relevant, lastIdx)
+    if (openIdx === -1) return null
+    range = {
+      start: relevant[openIdx].start.offset,
+      end: last.end.offset,
+    }
+    return extendWithPrefix(relevant, openIdx, range)
+  }
+
+  if (OPEN.has(last.kind)) {
+    // Cursor is right after an open bracket with no matching close before it.
+    // Return just the bracket itself so the evaluator reports an "unmatched
+    // bracket" error — correct and honest, no fallback to whole-buffer eval.
+    return { start: last.start.offset, end: last.end.offset }
+  }
+
+  if (!PREFIX.has(last.kind)) {
+    // Atom (symbol, number, keyword, string, nil, …)
+    range = { start: last.start.offset, end: last.end.offset }
+    return extendWithPrefix(relevant, lastIdx, range)
+  }
+
+  // Bare reader-macro prefix with nothing after it — nothing to eval.
+  return null
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+type Token = ReturnType<typeof tokenize>[number]
+
+/** Scan backwards from closeIdx to find the index of the matching open bracket. */
+function findMatchingOpen(relevant: Token[], closeIdx: number): number {
+  const closeKind = relevant[closeIdx].kind
+  const openKind =
+    closeKind === 'RParen'
+      ? 'LParen'
+      : closeKind === 'RBracket'
+        ? 'LBracket'
+        : 'LBrace'
+
+  let depth = 1
+  for (let i = closeIdx - 1; i >= 0; i--) {
+    const k = relevant[i].kind
+    if (k === closeKind) depth++
+    else if (
+      k === openKind ||
+      // AnonFnStart opens a RParen-closed scope just like LParen
+      (openKind === 'LParen' && k === 'AnonFnStart')
+    ) {
+      depth--
+      if (depth === 0) return i
+    }
+  }
+  return -1
+}
+
+/**
+ * If the token immediately before formStartIdx is a reader-macro prefix
+ * (`'`, `` ` ``, `~`, `~@`), extend the range to include it.
+ */
+function extendWithPrefix(
+  relevant: Token[],
+  formStartIdx: number,
+  range: FormRange,
+): FormRange {
+  if (formStartIdx > 0) {
+    const prev = relevant[formStartIdx - 1]
+    if (PREFIX.has(prev.kind)) {
+      return { start: prev.start.offset, end: range.end }
+    }
+  }
+  return range
+}