clojurific 0.12.2 → 0.12.3

package/cljf/cli.js

@@ -42,9 +42,10 @@ function parse(argv) {
 
 function run(command, args) {
   const child = spawn(command, args, { stdio: 'inherit' });
+  // forwarded: only a terminal signals the JVM too (SIGINT), not kill, an IDE
+  // or a process supervisor; a second SIGINT is harmless
   for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
-    // the terminal sends SIGINT to the JVM too, other signals are forwarded
-    process.on(signal, () => signal !== 'SIGINT' && child.kill(signal));
+    process.on(signal, () => child.kill(signal));
   }
   child.on('error', e => {
     console.error(`cljf: ${command}: ${e.message}`);

package/cljf/java.js

@@ -203,7 +203,8 @@ export async function setupJava({
   await fs.mkdir(dir, { recursive: true });
   const tmp = await fs.mkdtemp(path.join(dir, '.setup-'));
   try {
-    const archive = path.join(tmp, pkg.name);
+    // a name from the API, not a path
+    const archive = path.join(tmp, path.basename(pkg.name));
     try {
       await download(pkg.link, archive, { sha256: pkg.checksum, fetch });
     } catch (e) {

package/cljf/launcher.js

@@ -4,7 +4,7 @@
 // Classpaths are cached in the project's .cljf/cpcache, like the Clojure
 // CLI's .cpcache, until a deps.edn they were resolved from changes.
 import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -78,8 +78,10 @@ async function resolve({ project, aliases, java, cache, env, log }) {
     repository: env.CLJF_MAVEN_REPO || undefined,
     log,
   });
-  const input = `${cache}.resolve.edn`;
-  const output = `${cache}.resolve.json`;
+  // per process: another one may resolve the same classpath at the same time
+  const tmp = `${cache}.${process.pid}.${randomBytes(4).toString('hex')}`;
+  const input = `${tmp}.resolve.edn`;
+  const output = `${tmp}.resolve.json`;
   await fs.writeFile(input, edn({
     ':aliases': aliases,
     ':compiler': compiler,

package/package.json

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

package/vite-plugin-cljs/index.js

@@ -7,7 +7,7 @@
 // TypeScript files they import.
 import { spawn } from 'node:child_process';
 import fs from 'node:fs/promises';
-import { existsSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
@@ -31,16 +31,51 @@ async function sourceNamespace(file) {
   return ns;
 }
 
-// The ClojureScript sources pages load with module scripts
-async function pageSources(pages, root) {
-  const sources = [];
-  for (const page of pages) {
-    const html = await fs.readFile(page, 'utf8');
-    for (const [, src] of html.matchAll(/<script\b[^>]*\bsrc\s*=\s*["']([^"'?#]+\.clj[sc])["'][^>]*>/gi)) {
-      sources.push(src.startsWith('/') ? path.join(root, src) : path.resolve(path.dirname(page), src));
+const SCRIPT_SRC = /<script\b[^>]*\bsrc\s*=\s*["']([^"']+)["']/gi;
+// import "x", import x from "x", export … from "x", import("x")
+const IMPORT = /(?:\bimport\s*(?:[\w$*{}\s,]+\bfrom\s*)?|\bexport\s*[\w$*{}\s,]+\bfrom\s*|\bimport\s*\(\s*)["']([^"']+)["']/g;
+const SCRIPT_FILE = /\.(?:[cm]?[jt]sx?)$/;
+// extensionless imports, as TypeScript projects write them
+const SCRIPT_SUFFIXES = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '/index.ts', '/index.js'];
+
+// The file a page's script or a module's import names: root-absolute or
+// relative paths, not packages or aliases, which the bundler resolves
+function importedFile(spec, from, root) {
+  const file = spec.replace(/[?#].*$/, '');
+  if (!file.startsWith('/') && !file.startsWith('.')) return null;
+  return file.startsWith('/') ? path.join(root, file) : path.resolve(path.dirname(from), file);
+}
+
+// The ClojureScript sources the entries (pages and JavaScript or TypeScript
+// modules) load: the pages' scripts and the modules' imports, followed through
+// the project's modules
+async function entrySources(entries, root) {
+  const sources = new Set();
+  const seen = new Set();
+  const queue = [...entries];
+  while (queue.length) {
+    const file = queue.shift();
+    if (seen.has(file) || file.includes(`${path.sep}node_modules${path.sep}`)) continue;
+    seen.add(file);
+    let code;
+    try {
+      code = await fs.readFile(file, 'utf8');
+    } catch (e) {
+      continue;
+    }
+    for (const [, spec] of code.matchAll(file.endsWith('.html') ? SCRIPT_SRC : IMPORT)) {
+      const target = importedFile(spec, file, root);
+      if (!target) continue;
+      if (SOURCE_FILE.test(target)) {
+        if (existsSync(target)) sources.add(target);
+      } else {
+        const module = SCRIPT_SUFFIXES.map(suffix => target + suffix)
+          .find(f => SCRIPT_FILE.test(f) && existsSync(f) && !statSync(f).isDirectory());
+        if (module) queue.push(module);
+      }
     }
   }
-  return [...new Set(sources)];
+  return [...sources];
 }
 
 // Whether address is this machine's
@@ -73,14 +108,20 @@ async function commonJSPackage(root) {
   }
 }
 
-// A Rollup input (a file, files or {name: file}) as {name: absolute file}
+// A Rollup input (a file, files or {name: file}) as {name: absolute file},
+// files named by their path in the root without the extension, so pages with
+// the same file name in different directories (about/index.html) keep apart
 function inputObject(input, root) {
   if (!input) return {};
   if (typeof input === 'object' && !Array.isArray(input)) {
     return Object.fromEntries(Object.entries(input).map(([name, file]) => [name, path.resolve(root, file)]));
   }
-  return Object.fromEntries([].concat(input).map(file =>
-    [path.basename(file, path.extname(file)), path.resolve(root, file)]));
+  return Object.fromEntries([].concat(input).map(file => {
+    const absolute = path.resolve(root, file);
+    const relative = path.relative(root, absolute);
+    const name = relative.startsWith('..') || path.isAbsolute(relative) ? path.basename(absolute) : relative;
+    return [name.slice(0, name.length - path.extname(name).length).split(path.sep).join('/'), absolute];
+  }));
 }
 
 function ednString(s) {
@@ -315,6 +356,13 @@ export default function cljs(options) {
     return (compiled ? path.relative(outputDir, file) : path.relative(cwd, file)).split(path.sep).join('/');
   }
 
+  // Whether a ClojureScript source may be served: in Vite's root or
+  // server.fs.allow
+  function servedSource(file) {
+    const dirs = [config.root, ...(config.server?.fs?.allow ?? [])].map(dir => path.resolve(dir));
+    return SOURCE_FILE.test(file) && dirs.some(dir => file.startsWith(dir + path.sep));
+  }
+
   // The compiled module of a ClojureScript source file: its namespace's in the
   // build info, or its munged name
   async function compiledModule(file) {
@@ -325,7 +373,8 @@ export default function cljs(options) {
       `${ns.split('.').map(part => part.replace(/-/g, '_')).join('/')}.js`;
     const module = path.join(outputDir, relative);
     if (!existsSync(module)) {
-      throw new Error(`${ns} (${file}) isn't compiled: load it with a page's script, or add it to :main`);
+      throw new Error(`${ns} (${file}) isn't compiled: load it from a page's script or a module the pages ` +
+        'import (through relative or root-absolute imports, restarting Vite after adding it), or add it to :main');
     }
     return module;
   }
@@ -372,8 +421,8 @@ export default function cljs(options) {
       // the project's page, an input of builds and the dev server's /
       const indexHtml = existsSync(path.join(root, 'index.html')) ? path.join(root, 'index.html') : null;
       const userInput = userConfig.build?.rolldownOptions?.input ?? userConfig.build?.rollupOptions?.input;
-      const pages = Object.values(inputObject(userInput ?? indexHtml, root)).filter(f => f.endsWith('.html'));
-      pageNamespaces = await Promise.all((await pageSources(pages, root)).map(sourceNamespace));
+      const entries = Object.values(inputObject(userInput ?? indexHtml, root));
+      pageNamespaces = await Promise.all((await entrySources(entries, root)).map(sourceNamespace));
       if (env.command === 'build' && !env.isPreview) {
         const start = Date.now();
         if (userConfig.build?.watch) {
@@ -452,14 +501,17 @@ export default function cljs(options) {
       // A ClojureScript source: its compiled module, as a module importing it
       // when serving, which a page loading it by its source's URL and the
       // modules importing it by its own share
-      const file = source.split('?')[0];
+      const file = source.split(/[?#]/)[0];
       if (SOURCE_FILE.test(file) && !source.startsWith('\0')) {
+        // URLs are root-relative, files are only served from the project
         const candidates = [
-          ...(path.isAbsolute(file) ? [file] : []),
           ...(file.startsWith('/') ? [path.join(root, file)] : []),
-          ...(importer && !importer.startsWith('\0') ? [path.resolve(path.dirname(importer.split('?')[0]), file)] : []),
+          ...(importer && !importer.startsWith('\0') && !file.startsWith('/')
+            ? [path.resolve(path.dirname(importer.split('?')[0]), file)]
+            : []),
+          ...(path.isAbsolute(file) ? [file] : []),
         ];
-        const found = candidates.find(f => existsSync(f));
+        const found = candidates.find(f => servedSource(f) && existsSync(f));
         if (!found) return null;
         return config.command === 'build' ? compiledModule(found) : '\0' + SOURCE + found;
       }
@@ -479,7 +531,9 @@ export default function cljs(options) {
 
     async load(id) {
       if (id.startsWith('\0' + SOURCE)) {
-        const module = await compiledModule(id.slice(SOURCE.length + 1));
+        const file = id.slice(SOURCE.length + 1);
+        if (!servedSource(file)) this.error(`${file} is outside the project`);
+        const module = await compiledModule(file);
         return `import ${JSON.stringify(module)};\nexport * from ${JSON.stringify(module)};\n`;
       }
       // compiled namespaces with their source maps, to the ClojureScript sources
@@ -604,9 +658,10 @@ export default function cljs(options) {
       async handler(html, { filename }) {
         if (config.command !== 'serve') return html;
         const replacements = await Promise.all(
-          [...html.matchAll(/(<script\b[^>]*\bsrc\s*=\s*["'])([^"'?#]+\.clj[sc])(["'])/gi)].map(async match => {
+          // with a query or fragment, which the compiled module's URL keeps
+          [...html.matchAll(/(<script\b[^>]*\bsrc\s*=\s*["'])([^"'?#]+\.clj[sc])([?#][^"']*)?(["'])/gi)].map(async match => {
             const file = match[2].startsWith('/') ? path.join(config.root, match[2]) : path.resolve(path.dirname(filename), match[2]);
-            return [match[0], match[1] + devUrl(await compiledModule(file)) + match[3]];
+            return [match[0], match[1] + devUrl(await compiledModule(file)) + (match[3] ?? '') + match[4]];
           }));
         return replacements.reduce((result, [from, to]) => result.replace(from, to), html);
       },