clojurific 0.12.3 → 0.12.5

package/README.md

@@ -16,6 +16,9 @@ counts Clojurific's releases, starting from 1.
 
 ## Usage
 
+`npm create clojurific@latest` scaffolds a project (Vanilla, Reagent or UIx)
+like the one below, installs it and starts the dev server.
+
 Dependencies and source paths come from the project's `deps.edn`:
 
 ```clojure
@@ -50,8 +53,14 @@ or with the command line:
 npx cljf build '{:main my.app :output-dir "out"}'
 npx cljf -A:test watch @cljs.edn
 npx cljf classpath
+npx cljf repl
 ```
 
+`cljf repl` is a ClojureScript REPL evaluating in the pages the dev server
+runs, through its nREPL server: `cljs({ outputDir: 'target/cljs',
+compilerOptions: { repl: { 'nrepl-port': 0 } } })` with `nrepl/nrepl` in
+`deps.edn`.
+
 `cljf` resolves `deps.edn` with tools.deps, adds the compiler, and removes
 stock ClojureScript (`org.clojure/clojurescript`) that libraries depend on.
 Dependencies are downloaded into `~/.m2/repository`, which the Clojure CLI

package/cljf/cli.js

@@ -1,18 +1,22 @@
 #!/usr/bin/env node
-// cljf: builds and watches ClojureScript with the compiler (cljs.esm), on the
+// cljf: builds and watches ClojureScript with the compiler (cljf.esm), on the
 // project's classpath resolved from its deps.edn. See usage below.
 import { spawn } from 'node:child_process';
 import path from 'node:path';
 import { LauncherError } from './errors.js';
 import { classpath, compilerCommand, findJava, setupJava, version } from './launcher.js';
+import { repl } from './repl.js';
 
 const usage = `Usage: cljf [options] <command> [arguments]
 
 Commands:
-  build [options...]     compile once, cljs.esm's options: EDN maps, @file.edn
+  build [options...]     compile once, cljf.esm's options: EDN maps, @file.edn
                          and :profile keywords (defaults to :release)
   watch [options...]     compile, then recompile on changes (defaults to :dev)
   classpath              print the project's classpath
+  repl [--port <port>]   a ClojureScript REPL into the pages running the dev
+                         server's (or watch's) build, through its nREPL server
+                         (:repl {:nrepl-port 0}, port from .nrepl-port)
   setup-java [version]   download Eclipse Temurin (the latest LTS by default)
                          into cljf's cache, for machines without Java
 
@@ -65,7 +69,7 @@ async function main() {
     case 'build':
     case 'watch': {
       const cmd = await compilerCommand({ ...opts, interactive, log });
-      run(cmd.command, [...cmd.args, '-m', 'cljs.esm', command, ...args]);
+      run(cmd.command, [...cmd.args, '-m', 'cljf.esm', command, ...args]);
       break;
     }
     case 'classpath': {
@@ -73,6 +77,11 @@ async function main() {
       console.log(cp.classpath.join(path.delimiter));
       break;
     }
+    case 'repl': {
+      const i = args.indexOf('--port');
+      process.exit(await repl({ port: i >= 0 ? Number(args[i + 1]) : undefined }));
+      break;
+    }
     case 'setup-java': {
       const { java } = await setupJava({ version: args[0], log });
       console.log(java);

package/cljf/launcher.js

@@ -141,8 +141,8 @@ export async function classpath({ cwd = process.cwd(), aliases = [], force = fal
 
 /**
  * The command starting clojure.main with the compiler on the project's
- * classpath: {command, args, java, classpath}, cljs.esm's arguments go after
- * args, i.e. [...args, '-m', 'cljs.esm', 'build']. Options: cwd (the
+ * classpath: {command, args, java, classpath}, cljf.esm's arguments go after
+ * args, i.e. [...args, '-m', 'cljf.esm', 'build']. Options: cwd (the
  * project, with its deps.edn), aliases, force (resolve the classpath again),
  * interactive (offer to install Java), env and log.
  */

package/cljf/repl.js

@@ -0,0 +1,335 @@
+// cljf repl: a ClojureScript REPL in the terminal, evaluating in the pages
+// running a watched build. It's an nREPL client of the watcher's nREPL server
+// (:repl {:nrepl-port 0}, see cljf.esm.repl.nrepl), whose session it
+// switches to ClojureScript with (cljf.esm.repl/repl).
+import { existsSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import net from 'node:net';
+import path from 'node:path';
+import readline from 'node:readline';
+import { LauncherError } from './errors.js';
+
+// bencode, nREPL's encoding: dicts, lists, integers and (UTF-8) strings
+
+export function bencode(v) {
+  if (typeof v === 'number') return Buffer.from(`i${Math.trunc(v)}e`);
+  if (typeof v === 'string' || Buffer.isBuffer(v)) {
+    const bytes = Buffer.isBuffer(v) ? v : Buffer.from(v);
+    return Buffer.concat([Buffer.from(`${bytes.length}:`), bytes]);
+  }
+  if (Array.isArray(v)) return Buffer.concat([Buffer.from('l'), ...v.map(bencode), Buffer.from('e')]);
+  const keys = Object.keys(v).filter(k => v[k] !== undefined).sort();
+  return Buffer.concat([Buffer.from('d'), ...keys.flatMap(k => [bencode(k), bencode(v[k])]), Buffer.from('e')]);
+}
+
+const INCOMPLETE = Symbol('incomplete');
+
+// The value at buf[i], [value, next index], or INCOMPLETE
+function decodeAt(buf, i) {
+  if (i >= buf.length) return INCOMPLETE;
+  const c = String.fromCharCode(buf[i]);
+  if (c === 'i') {
+    const end = buf.indexOf('e', i);
+    return end < 0 ? INCOMPLETE : [Number(buf.toString('latin1', i + 1, end)), end + 1];
+  }
+  if (c === 'l' || c === 'd') {
+    const items = [];
+    let j = i + 1;
+    while (j < buf.length && buf[j] !== 0x65) {
+      const item = decodeAt(buf, j);
+      if (item === INCOMPLETE) return INCOMPLETE;
+      items.push(item[0]);
+      j = item[1];
+    }
+    if (j >= buf.length) return INCOMPLETE;
+    if (c === 'l') return [items, j + 1];
+    const dict = {};
+    for (let k = 0; k < items.length; k += 2) dict[items[k]] = items[k + 1];
+    return [dict, j + 1];
+  }
+  if (c >= '0' && c <= '9') {
+    const colon = buf.indexOf(':', i);
+    if (colon < 0) return INCOMPLETE;
+    const start = colon + 1;
+    const end = start + Number(buf.toString('latin1', i, colon));
+    return end > buf.length ? INCOMPLETE : [buf.toString('utf8', start, end), end];
+  }
+  throw new Error(`bencode: unexpected ${JSON.stringify(c)}`);
+}
+
+/** Decodes the values of a byte stream, as chunks arrive. */
+export class Decoder {
+  #buf = Buffer.alloc(0);
+
+  /** The values chunk completes. */
+  push(chunk) {
+    this.#buf = Buffer.concat([this.#buf, chunk]);
+    const values = [];
+    for (;;) {
+      const decoded = decodeAt(this.#buf, 0);
+      if (decoded === INCOMPLETE) return values;
+      values.push(decoded[0]);
+      this.#buf = this.#buf.subarray(decoded[1]);
+    }
+  }
+}
+
+/**
+ * Whether code's forms are all closed, so that the REPL evaluates it rather
+ * than reading another line: no open (, [ or {, string or regex. Extra
+ * closing brackets are the reader's to report.
+ */
+export function complete(code) {
+  let depth = 0;
+  for (let i = 0; i < code.length; i++) {
+    const c = code[i];
+    if (c === ';') {
+      while (i < code.length && code[i] !== '\n') i++;
+    } else if (c === '\\') {
+      i++;
+    } else if (c === '"') {
+      for (i++; i < code.length && code[i] !== '"'; i++) if (code[i] === '\\') i++;
+      if (i >= code.length) return false;
+    } else if ('([{'.includes(c)) {
+      depth++;
+    } else if (')]}'.includes(c)) {
+      depth--;
+    }
+  }
+  return depth <= 0;
+}
+
+/** An nREPL connection: requests whose responses end with status done. */
+export class Connection {
+  #socket;
+  #ids = 0;
+  #pending = new Map();
+
+  constructor(socket) {
+    this.#socket = socket;
+    const decoder = new Decoder();
+    socket.on('data', chunk => {
+      for (const msg of decoder.push(chunk)) {
+        const request = this.#pending.get(msg.id);
+        if (!request) continue;
+        request.onResponse(msg);
+        if (msg.status?.includes('done')) {
+          this.#pending.delete(msg.id);
+          request.resolve(msg);
+        }
+      }
+    });
+  }
+
+  /** A message id for request. */
+  newId() {
+    return String(++this.#ids);
+  }
+
+  /**
+   * Sends msg (with an id from newId, or a new one), calls onResponse with
+   * its responses; resolves to the last.
+   */
+  request(msg, onResponse = () => {}) {
+    const id = msg.id ?? this.newId();
+    return new Promise(resolve => {
+      this.#pending.set(id, { onResponse, resolve });
+      this.#socket.write(bencode({ ...msg, id }));
+    });
+  }
+
+  close() {
+    this.#socket.end();
+  }
+}
+
+function connect(port, host) {
+  return new Promise((resolve, reject) => {
+    const socket = net.connect(port, host);
+    socket.once('connect', () => {
+      socket.off('error', reject);
+      resolve(socket);
+    });
+    socket.once('error', reject);
+  });
+}
+
+/**
+ * Connects to the nREPL server on port, or the one in cwd's .nrepl-port,
+ * waiting for it to start (the dev server writes the file once it built).
+ */
+export async function connectToServer({ cwd = process.cwd(), port, host = '127.0.0.1', log = () => {}, interval = 500 } = {}) {
+  const portFile = path.join(cwd, '.nrepl-port');
+  let waiting = false;
+  for (;;) {
+    const p = port ?? (existsSync(portFile) ? Number((await fs.readFile(portFile, 'utf8')).trim()) : null);
+    if (p) {
+      try {
+        return await connect(p, host);
+      } catch (e) {
+        if (port) throw new LauncherError(`cljf repl: no nREPL server on ${host}:${port}: ${e.message}`);
+      }
+    }
+    if (!waiting) {
+      log(`; waiting for the nREPL server of the dev server (npm run dev) or cljf watch, with :repl {:nrepl-port 0},\n; to write ${portFile}`);
+      waiting = true;
+    }
+    await new Promise(resolve => setTimeout(resolve, interval));
+  }
+}
+
+async function readHistory(file) {
+  try {
+    return (await fs.readFile(file, 'utf8')).split('\n').filter(Boolean).reverse();
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * The REPL: reads forms from input, evaluates them in the session switched
+ * to ClojureScript, writes their output and values to output (errors and
+ * warnings to errorOutput). Resolves to the exit code once input ends or
+ * :cljs/quit.
+ */
+export async function repl({
+  cwd = process.cwd(),
+  port,
+  host,
+  input = process.stdin,
+  output = process.stdout,
+  errorOutput = process.stderr,
+  terminal = Boolean(input.isTTY && output.isTTY),
+  historyFile = path.join(cwd, '.cljf', 'repl-history'),
+} = {}) {
+  const socket = await connectToServer({ cwd, port, host, log: line => errorOutput.write(`${line}\n`) });
+  const conn = new Connection(socket);
+  let closing = false;
+  const closed = new Promise(resolve => socket.on('close', resolve));
+  socket.on('error', () => {});
+
+  const write = (stream, text) => text && stream.write(text);
+  const { 'new-session': session } = await conn.request({ op: 'clone' });
+  let failed = false;
+  await conn.request({ op: 'eval', session, code: '(cljf.esm.repl/repl)' }, msg => {
+    write(output, msg.out);
+    write(errorOutput, msg.err);
+    if (msg.ex) failed = true;
+  });
+  if (failed) {
+    conn.close();
+    throw new LauncherError('cljf repl: the nREPL server has no ClojureScript REPL (cljf.esm.repl), is it the dev server\'s?');
+  }
+
+  const history = terminal ? await readHistory(historyFile) : [];
+  const rl = readline.createInterface({ input, output, terminal, history, historySize: 1000, removeHistoryDuplicates: true });
+  if (terminal) {
+    rl.on('history', lines => {
+      fs.mkdir(path.dirname(historyFile), { recursive: true })
+        .then(() => fs.writeFile(historyFile, `${[...lines].reverse().join('\n')}\n`))
+        .catch(() => {});
+    });
+  }
+
+  let ns = 'cljs.user';
+  let pending = '';
+  let evaluating = null;
+  let interrupted = false;
+  const prompt = () => {
+    if (!terminal) return;
+    rl.setPrompt(pending ? `${' '.repeat(Math.max(0, ns.length - 1))}#_=> ` : `${ns}=> `);
+    rl.prompt();
+  };
+
+  const done = new Promise(resolve => {
+    const quit = code => {
+      closing = true;
+      rl.close();
+      // the server forgets the session, unless it doesn't answer
+      const timeout = new Promise(r => setTimeout(r, 1000).unref());
+      Promise.race([conn.request({ op: 'close', session }), timeout]).finally(() => {
+        conn.close();
+        resolve(code);
+      });
+    };
+    closed.then(() => {
+      if (closing) return;
+      errorOutput.write('\n; the nREPL server closed the connection\n');
+      closing = true;
+      rl.close();
+      resolve(1);
+    });
+
+    rl.on('SIGINT', () => {
+      if (evaluating) {
+        conn.request({ op: 'interrupt', session, 'interrupt-id': evaluating });
+      } else if (pending || rl.line) {
+        pending = '';
+        interrupted = false;
+        rl.write(null, { ctrl: true, name: 'u' });
+        output.write('\n');
+        prompt();
+      } else if (interrupted) {
+        quit(0);
+      } else {
+        interrupted = true;
+        output.write('\n; Ctrl-C again, Ctrl-D or :cljs/quit to quit\n');
+        prompt();
+      }
+    });
+
+    // lines are read one at a time: a form waits for the one before
+    const lines = [];
+    let busy = false;
+    const next = async () => {
+      if (busy) return;
+      busy = true;
+      while (lines.length) {
+        const line = lines.shift();
+        if (line === null) {
+          quit(0);
+          return;
+        }
+        interrupted = false;
+        pending += `${line}\n`;
+        if (!complete(pending)) {
+          prompt();
+          continue;
+        }
+        const code = pending;
+        pending = '';
+        if (!code.trim()) {
+          prompt();
+          continue;
+        }
+        if (code.trim() === ':cljs/quit') {
+          quit(0);
+          return;
+        }
+        evaluating = conn.newId();
+        await conn.request({ op: 'eval', session, code, ns, id: evaluating }, msg => {
+          write(output, msg.out);
+          write(errorOutput, msg.err);
+          if (msg.value !== undefined) output.write(`${msg.value}\n`);
+          if (msg.ns) ns = msg.ns;
+        });
+        evaluating = null;
+        if (closing) return;
+        prompt();
+      }
+      busy = false;
+    };
+    rl.on('line', line => {
+      lines.push(line);
+      next();
+    });
+    rl.on('close', () => {
+      if (closing) return;
+      lines.push(null);
+      next();
+    });
+  });
+
+  prompt();
+  return done;
+}

package/karma-esm/adapter.js

@@ -1,12 +1,12 @@
-// Karma adapter for a cljs.esm test bundle (an ES module) run by
-// cljs.esm.karma/start. Add it to Karma's files, serve the bundle's directory
+// Karma adapter for a cljf.esm test bundle (an ES module) run by
+// cljf.esm.karma/start. Add it to Karma's files, serve the bundle's directory
 // (included: false), and name its entry module in client.args:
 //
 //   files: ['<this file>', {pattern: 'build/ci-test/**/*', included: false}],
 //   client: {args: ['/base/build/ci-test/my.test-runner.js']},
 //
 // Karma calls start once the page has loaded, module scripts may not have run
-// yet: cljs.esm.karma/start runs the tests in whichever order the two happen.
+// yet: cljf.esm.karma/start runs the tests in whichever order the two happen.
 window.__karma__.start = function () {
   window.__karmaStarted = true;
   if (window.__karmaRun) window.__karmaRun();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clojurific",
-  "version": "0.12.3",
+  "version": "0.12.5",
   "description": "ClojureScript compiled to ES modules, bundled by Vite",
   "license": "EPL-1.0",
   "repository": {

package/vite-plugin-cljs/index.js

@@ -16,7 +16,7 @@ import { Worker } from 'node:worker_threads';
 import { compilerCommand } from '../cljf/launcher.js';
 import { pruneChunks, propertyRenames } from './prune.js';
 
-const EVENT_PREFIX = '[cljs.esm] ';
+const EVENT_PREFIX = '[cljf.esm] ';
 const NPM_AS = 'cljs-npm-as:';
 // a ClojureScript source loaded by a page or imported from JavaScript, which
 // the dev server serves as an import of its compiled module
@@ -227,11 +227,11 @@ export default module.exports;
  *   the compiler added and stock ClojureScript removed, see cljf/launcher.js.
  * @param {string[]} [options.command] starts Clojure with the compiler on the
  *   classpath instead of the launcher, i.e. ["clojure", "-M:cljs"],
- *   cljs.esm's arguments follow
+ *   cljf.esm's arguments follow
  * @param {string} [options.cwd] the compiler's working directory, with the
  *   project's deps.edn, defaults to Vite's root (the project's directory)
  * @param {string} [options.config] compiler options file (EDN, see
- *   cljs.esm/load-options), relative to cwd
+ *   cljf.esm/load-options), relative to cwd
  * @param {string} [options.profile] profile of the config file, defaults to
  *   dev when serving and release when building
  * @param {string} options.outputDir the compiler's output directory, relative
@@ -285,7 +285,7 @@ export default function cljs(options) {
 
   function run(args, onEvent) {
     const [cmd, ...cmdArgs] = compiler;
-    const child = spawn(cmd, [...cmdArgs, '-m', 'cljs.esm', ...args], {
+    const child = spawn(cmd, [...cmdArgs, '-m', 'cljf.esm', ...args], {
       cwd,
       stdio: ['pipe', 'pipe', 'pipe'],
     });
@@ -686,7 +686,7 @@ export default function cljs(options) {
         server.ws.send(problem);
       };
       server.ws.on('connection', socket => problem && socket.send(JSON.stringify(problem)));
-      // The REPL (cljs.esm.repl): pages running the build (cljs.esm.repl-runtime)
+      // The REPL (cljf.esm.repl): pages running the build (cljf.esm.repl-runtime)
       // say hello over Vite's websocket, each connection gets a runtime id. Their
       // cljs:repl messages go to the compiler as `repl <json>` lines, the
       // compiler's repl-send events to the page of their runtime id.