create-clojurific 0.12.6 → 0.12.7

package/README.md

@@ -8,9 +8,9 @@ Scaffolds a ClojureScript project compiled by
 npm create clojurific@latest
 ```
 
-It asks for the project's name, a framework (Vanilla, [Reagent](https://reagent-project.github.io)
-or [UIx](https://github.com/pitch-io/uix)), and whether to install the
-dependencies and start the dev server. The project's namespace comes from its
+It asks for the project's name, a framework (Vanilla, [Reagent](https://reagent-project.github.io/),
+[UIx](https://uix-cljs.dev/), or [Hono](https://hono.dev/) for a backend), and
+whether to install the dependencies and start the dev server. The project's namespace comes from its
 name: `my-app` gets `src/my_app/core.cljs`, `my-app.core`. The compiler needs
 Node.js 20 and Java 17 or later; when Java is missing, it offers to download
 Eclipse Temurin before starting the dev server.
@@ -19,16 +19,22 @@ Projects have the scripts `dev` (Vite's dev server, hot reloading), `build`,
 `preview`, and `repl`, a ClojureScript REPL evaluating in the pages the dev
 server runs (`cljf repl`, through the dev server's nREPL server).
 
+The Hono project is a backend without pages: its app is a namespace the dev
+server runs with [`@hono/vite-dev-server`](https://github.com/honojs/vite-plugins),
+hot reloading it, and its REPL evaluates there. `build` bundles it into a
+Node.js server, `dist/index.js`, which `start` runs.
+
 The options answer the questions, i.e. in scripts:
 
 ```sh
 npm create clojurific@latest my-app -- --template reagent
 npm create clojurific@latest my-app -- --template uix --immediate
+npm create clojurific@latest my-api -- --template hono
 ```
 
 | Option | |
 |---|---|
-| `-t`, `--template <name>` | `vanilla`, `reagent` or `uix` |
+| `-t`, `--template <name>` | `vanilla`, `reagent`, `uix` or `hono` |
 | `--overwrite` | remove the target directory's files |
 | `-i`, `--immediate` | install the dependencies and start the dev server |
 | `--no-interactive` | don't ask, use the defaults (`vanilla`, no install) |

package/create.js

@@ -12,7 +12,7 @@ export const version = JSON.parse(readFileSync(path.join(packageRoot, 'package.j
 
 export const templatesDir = path.join(packageRoot, 'templates');
 
-export const TEMPLATES = ['vanilla', 'reagent', 'uix'];
+export const TEMPLATES = ['vanilla', 'reagent', 'uix', 'hono'];
 
 export const DEFAULT_PROJECT = 'clojurific-project';
 

package/index.js

@@ -27,8 +27,9 @@ Options:
 
 const FRAMEWORKS = [
   { value: 'vanilla', label: 'Vanilla', color: c.yellow },
-  { value: 'reagent', label: 'Reagent', color: c.cyan },
-  { value: 'uix', label: 'UIx', color: c.magenta },
+  { value: 'reagent', label: 'Reagent', color: c.cyan, hint: 'https://reagent-project.github.io/' },
+  { value: 'uix', label: 'UIx', color: c.magenta, hint: 'https://uix-cljs.dev/' },
+  { value: 'hono', label: 'Hono (backend only)', color: c.red, hint: 'https://hono.dev/' },
 ];
 
 function parse(argv) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-clojurific",
-  "version": "0.12.6",
+  "version": "0.12.7",
   "description": "Scaffolds a ClojureScript project compiled by Clojurific and bundled by Vite: npm create clojurific@latest",
   "license": "EPL-1.0",
   "repository": {

package/prompts.js

@@ -129,9 +129,14 @@ export function text({ message, placeholder = '', defaultValue = '' }) {
   });
 }
 
-/** One of options ({value, label, color}), initialValue first. */
+/** One of options ({value, label, color, hint}), initialValue first. */
 export function select({ message, options, initialValue }) {
   const paint = option => (option.color ? option.color(option.label) : option.label);
+  // hints (i.e. links) aligned after the longest label
+  const width = Math.max(...options.map(o => o.label.length));
+  const line = option => (option.hint
+    ? `${paint(option)}${' '.repeat(width - option.label.length + 2)}${c.dim(option.hint)}`
+    : paint(option));
   return prompt({
     state: { index: Math.max(0, options.findIndex(o => o.value === initialValue)) },
     value: s => options[s.index].value,
@@ -142,8 +147,8 @@ export function select({ message, options, initialValue }) {
     },
     render(s, status) {
       const lines = options.map((option, i) => (i === s.index
-        ? `${c.green(S.radioOn)} ${paint(option)}`
-        : `${c.dim(S.radioOff)} ${c.dim(paint(option))}`));
+        ? `${c.green(S.radioOn)} ${line(option)}`
+        : `${c.dim(S.radioOff)} ${c.dim(line(option))}`));
       lines.push(`${c.dim('↑/↓')} to navigate ${c.dim('•')} ${c.dim('Enter:')} confirm`);
       return title(message, status) + body(status, lines, paint(options[s.index]));
     },

package/templates/hono/README.md

@@ -0,0 +1,25 @@
+# {{name}}
+
+A [Hono](https://hono.dev) backend in ClojureScript, compiled by
+[Clojurific](https://github.com/WhimsicalCode/clojurific) and bundled by
+[Vite](https://vite.dev).
+
+- `npm run dev` starts the dev server, which hot reloads changed namespaces
+- `npm run repl` starts a ClojureScript REPL evaluating in the backend the dev
+  server runs (start `npm run dev` first)
+- `npm run build` bundles the backend into `dist/index.js`, a Node.js server
+  (no `node_modules` needed)
+- `npm start` runs it (on port 3000)
+
+The app is `src/{{nsDir}}/core.cljs`. It's compiled as a `:js-entries` module
+exporting the app (see `vite.config.mjs`), which
+[`@hono/vite-dev-server`](https://github.com/honojs/vite-plugins) serves and
+`@hono/vite-build` bundles. Changed namespaces are hot reloaded in place:
+`defonce` keeps its value.
+
+ClojureScript dependencies go in `deps.edn`, npm packages in `package.json`.
+The compiler needs Java 17 or later: `npx cljf setup-java` downloads one.
+
+Editors connect to the dev server's nREPL server, its port in `.nrepl-port`
+(i.e. Calva's "Connect to a running REPL", CIDER's `cider-connect-clj`), and
+evaluate `(cljf.esm.repl/repl)` to switch the session to ClojureScript.

package/templates/hono/_gitignore

@@ -0,0 +1,8 @@
+node_modules
+dist
+target
+.cljf
+.cpcache
+.nrepl-port
+*.local
+.DS_Store

package/templates/hono/deps.edn

@@ -0,0 +1,3 @@
+{:paths ["src"]
+ :deps {;; the dev server's nREPL server, for npm run repl and editors
+        nrepl/nrepl {:mvn/version "1.8.0"}}}

package/templates/hono/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "clojurific-project",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "start": "node dist/index.js",
+    "repl": "cljf repl"
+  },
+  "dependencies": {
+    "@hono/node-server": "^2.1.4",
+    "hono": "^4.13.13"
+  },
+  "devDependencies": {
+    "@hono/vite-build": "^1.11.1",
+    "@hono/vite-dev-server": "^0.26.1",
+    "clojurific": "*",
+    "vite": "^8.3.3"
+  }
+}

package/templates/hono/src/{{nsDir}}/core.cljs

@@ -0,0 +1,14 @@
+(ns {{ns}}
+  (:require ["hono" :refer [Hono]]))
+
+;; kept across hot reloads
+(defonce clicks (atom 0))
+
+(defn- state [c]
+  (.json c #js {:clicks @clicks}))
+
+(def app
+  (doto (Hono.)
+    (.get "/" (fn [c] (.text c "Hello Hono! Edit src/{{nsDir}}/core.cljs and save to hot reload")))
+    (.get "/clicks" state)
+    (.post "/clicks" (fn [c] (swap! clicks inc) (state c)))))

package/templates/hono/vite.config.mjs

@@ -0,0 +1,33 @@
+import cljs from 'clojurific/vite';
+import devServer from '@hono/vite-dev-server';
+import build from '@hono/vite-build/node';
+
+// the backend: a module exporting the Hono app (:js-entries below)
+const entry = 'target/cljs/cljs-esm-entries/server.js';
+
+export default {
+  plugins: [
+    cljs({
+      outputDir: 'target/cljs',
+      compilerOptions: {
+        'js-entries': { server: { exports: { default: "'{{ns}}/app" } } },
+        // the dev server starts an nREPL server, its port in .nrepl-port
+        repl: { 'nrepl-port': 0 },
+      },
+      // the dev server runs the backend once compiled, not on its first
+      // request: the REPL evaluates in it
+      ssrEntries: ['server'],
+      // no pages, no manifest of their scripts
+      manifest: false,
+    }),
+    devServer({
+      entry,
+      // ssrLoadModule's runner has no HMR, it would re-run a changed module
+      // (and its importers), the ssr environment's runner hot reloads
+      // namespaces in place: defonce keeps its value
+      loadModule: async (server, entry) => (await server.environments.ssr.runner.import(entry)).default,
+    }),
+    // the cljs plugin minifies, after pruning unused protocol implementations
+    build({ entry, emptyOutDir: true, minify: false }),
+  ],
+};