Shadow CLJS

https://shadow-cljs.github.io/docs/
Admin
Shadow CLJS is a build tool that provides everything needed to compile ClojureScript projects with a...
Tokens:33,858
Snippets:458
Trust Score:8.3
Update:4 months ago
Show doc for...
Tokens:
Raw
### Karma CI Setup - package.json

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example package.json configuration for setting up Karma for continuous integration testing. Includes necessary devDependencies.

```json
{
  "name": "CITests",
  "version": "1.0.0",
  "description": "Testing",
  ...
  "devDependencies": {
    "karma": "^2.0.0",
    "karma-chrome-launcher": "^2.2.0",
    "karma-cljs-test": "^0.1.0",
    ...
  },
  "author": "",
  "license": "MIT"
}
```

--------------------------------

### Start and Compile with Shadow-cljs REPL

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Demonstrates starting the shadow-cljs development server and compiling a build from a Leiningen REPL.

```clojure
user=> (require '[shadow.cljs.devtools.server :as server])
nil
user=> (server/start!)
...
:shadow.cljs.devtools.server/started
user=> (require '[shadow.cljs.devtools.api :as shadow])
nil
user=> (shadow/compile :foo)
...
```

--------------------------------

### Start Shadow-cljs REPL Server

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Start a shadow-cljs server process that can be controlled via a REPL.

```bash
$ shadow-cljs clj-repl
```

--------------------------------

### Start and Connect to a Shadow-cljs Build REPL

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Use these commands to start a build watch and then connect to its associated REPL session. Use `:cljs/quit` to return to Clojure.

```clojure
(shadow/watch :the-build)
(shadow/repl :the-build)
```

--------------------------------

### Example shadow-cljs.edn Configuration

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

An example shadow-cljs.edn configuration including dependencies, source paths, and a browser build.

```clojure
{:dependencies
 [[reagent "0.8.0-alpha2"]] 

 :source-paths
 ["src"] 

 :builds
 {:app {:target :browser
        :output-dir "public/js"
        :asset-path "/js"
        :modules {:main {:entries [my.app]}}}}}
```

--------------------------------

### Install Missing JS Dependency Example

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example of manually installing required JavaScript packages when a library doesn't declare them.

```bash
npm install react react-dom create-react-class
```

--------------------------------

### Start Shadow-cljs Server

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Start shadow-cljs in server mode for faster command execution. Use CTRL+C to stop.

```bash
$ shadow-cljs server
```

--------------------------------

### Example shadow-cljs.edn config

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Shows a basic structure for defining builds in shadow-cljs.edn.

```clojure
{... 
 :builds
 {:app
  {:target :browser
   :output-dir "public/js"
   ...}}}
```

--------------------------------

### Dependencies Configuration Example

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example of declaring Clojure(Script) dependencies in shadow-cljs.edn.

```clojure
{:source-paths ["src"]
 :dependencies [[reagent "0.9.1"]]
 :builds ...}
```

--------------------------------

### Example shadow-cljs.edn with defaults

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Demonstrates setting build-defaults and target-defaults for :browser builds in shadow-cljs.edn.

```clojure
{... 
 :build-defaults
 {:closure-defines
   {your.app/VERBOSE true}}

 :target-defaults
 {:browser
   {:js-options
     {:resolve {"react" {:target :global
                         :global "React"}}}}}

 :builds
 {:app
  {:target :browser
   ...}}}
```

--------------------------------

### Start Clojure REPL

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Starts a Clojure REPL that can be used to control the shadow-cljs process and execute build commands. This REPL can be upgraded to a ClojureScript REPL.

```bash
$ shadow-cljs clj-repl
...
shadow-cljs - REPL - see (help), :repl/quit to exit
[1:0]~shadow.user=>
```

--------------------------------

### Sample Leiningen Project Configuration

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example project.clj demonstrating how to configure Leiningen for shadow-cljs, including source paths and dependencies.

```clojure
(defproject my-awesome-project
  ...
  :profiles
  {:cljs
   {:source-paths ["src/cljs"]
    :dependencies [[thheller/shadow-cljs "..."]
                   [reagent "0.8.1"]]}})
```

--------------------------------

### Control Shadow-cljs via Clojure REPL API

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Demonstrates how to use the `shadow.cljs.devtools.api` namespace (aliased as `shadow`) to control shadow-cljs builds and REPLs from a Clojure REPL. Includes examples for watch, compile, release, and starting different REPL types.

```clojure
;; shadow-cljs watch foo
(shadow.cljs.devtools.api/watch :foo)
;; this is identical, due to the provided ns alias
(shadow/watch :foo)
;; shadow-cljs watch foo --verbose
(shadow/watch :foo {:verbose true})
;; shadow-cljs compile foo
(shadow/compile :foo)
;; shadow-cljs release foo
(shadow/release :foo)

;; shadow-cljs browser-repl
(shadow/browser-repl)
;; shadow-cljs node-repl
(shadow/node-repl)
;; shadow-cljs cljs-repl foo
(shadow/repl :foo)

;; Once you are in a CLJS REPL you can use
:repl/quit
;; or
:cljs/quit
;; to drop back down to CLJ.
```

--------------------------------

### manifest.json Configuration Example

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configuration snippet for shadow-cljs to generate the output manifest as a JSON file instead of EDN.

```clojure
{... 
 :builds
   {:app
     {:target :browser
      ...
      :build-options {:manifest-name "manifest.json"}
      :modules {:main  {:entries [my.app]}
                :extra {:entries [my.app.extra]
                        :depends-on #{:main}}}}}}
```

--------------------------------

### Install Shadow-CLJS via Yarn

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Command to install shadow-cljs as a development dependency using Yarn.

```bash
$ yarn add --dev shadow-cljs
```

--------------------------------

### Install Shadow-CLJS via npm

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Command to install shadow-cljs as a development dependency using npm.

```bash
$ npm install --save-dev shadow-cljs
```

--------------------------------

### Start Browser REPL

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Starts a blank ClojureScript REPL and opens an associated browser window for code execution. Closing the browser window will stop the REPL.

```bash
$ shadow-cljs browser-repl
```

--------------------------------

### EDN Configuration: Nested Option Example

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Demonstrates a nested EDN configuration structure for build options, with elided content.

```clojure
{...
 :builds {:build-id {...
                     :output-dir "resources/public/js"}}}
...
```

--------------------------------

### Open File Command Execution Example (Idea)

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Illustrates the command executed by shadow-cljs when the Idea IDE is configured for opening files. Shows how keywords are substituted with actual paths and line numbers.

```bash
$ idea /path/to/project-root --line 3 /path/to/project-root/src/main/demo/foo.cljs
```

--------------------------------

### Configure Modules with Release Versions

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example configuration for defining modules where output filenames will include the release version.

```clojure
{...
 :builds
   {:app
     {:target :browser
      ...
      :output-dir "public/js"
      :asset-path "/js"
      :modules {:main  {:entries [my.app]}
                :extra {:entries [my.app.extra]
                        :depends-on #{:main}}}}}}
```

--------------------------------

### Sample manifest.edn Output

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example of a manifest.edn file generated by shadow-cljs, showing module IDs, output filenames (with hashes), and dependencies.

```clojure
ளது{:module-id :common,
:name :common,
:output-name "common.15D142F7841E2838B46283EA558634EE.js",
:entries [...],
:depends-on #{},
:sources [...]} 
 {:module-id :page-a,
:name :page-a,
:output-name "page-a.D8844E305644135CBD5CBCF7E359168A.js",
:entries [...],
:depends-on #{:common},
:sources [...]} 
 ...
```

--------------------------------

### Running Babel for Pre-processing

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Provides command-line examples for using Babel to convert JavaScript files (e.g., .jsx) to a target directory, including a watch mode for development.

```bash
$ babel src/js --out-dir src/gen
# or during development
$ babel src/js --out-dir src/gen --watch
```

--------------------------------

### Custom Browser Test Runner Namespace

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example of a custom namespace for running browser tests. It includes init, start, and stop functions for test lifecycle management.

```clojure
(ns tests.client-test-main
  {:dev/always true}
  (:require [shadow.test :as st]
            [shadow.test.env :as env]
            [cljs-test-display.core :as ctd]
            [shadow.dom :as dom]))

(defn start []
  (-> (env/get-test-data)
      (env/reset-test-data!))

  (st/run-all-tests (ctd/init! "test-root")))

(defn stop [done]
  ; tests can be async. You must call done so that the runner knows you actually finished
  (done))

(defn ^:export init []
  (dom/append [:div#test-root])
  (start))
```

--------------------------------

### Install JavaScript Package with npm

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Commands to install JavaScript dependencies using npm or yarn.

```bash
# npm
$ npm install the-thing

# yarn
$ yarn add the-thing
```

--------------------------------

### Start Shadow-CLJS Watcher

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Initiate the shadow-cljs build watcher from the terminal. This command is necessary before connecting tools like Fireplace.vim.

```bash
npx shadow-cljs watch frontend

```

--------------------------------

### Basic Compiler Options Configuration

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example of setting compiler options within the build configuration. Use this to customize code generation for specific targets.

```clojure
{
 :dependencies [...] 
 :builds
 {:app
  {:target :browser
   ...
   :compiler-options {:fn-invoke-direct true}}}}

```

--------------------------------

### Shadow-CLJS Help via npx

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Command to invoke shadow-cljs help using npx for local npm installs.

```bash
# npm
$ npx shadow-cljs help
```

--------------------------------

### Shadow-cljs Configuration for Hot Code Reload

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

This configuration snippet shows how to integrate the start and stop functions for hot code reload within a shadow-cljs build. The `:before-load-async` and `:after-load` options are used to specify the stop and start hooks, respectively.

```clojure
{... 
 :builds
   { :script {... as before

              ; add in reload hooks
              :devtools {:before-load-async demo.script/stop
                         :after-load demo.script/start}}}}
```

--------------------------------

### Shadow-CLJS Help via Yarn

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Command to invoke shadow-cljs help using yarn for local npm installs.

```bash
# yarn
$ yarn shadow-cljs help
```

--------------------------------

### Configure Module Hash Names

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example configuration to enable MD5 hashing for generated output module filenames. A number can specify hash length.

```clojure
{...
 :builds
   {:app
     {:target :browser
      ...
      :output-dir "public/js"
      :asset-path "/js"
      :module-hash-names true
      :modules {:main  {:entries [my.app]}
                :extra {:entries [my.app.extra]
                        :depends-on #{:main}}}}}}
```

--------------------------------

### Example Build Hook Function

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

This is an example of a Clojure function that can be used as a build hook. It includes metadata `{:shadow.build/stage :flush}` to specify execution after the `:flush` stage and prints a message. The function must return the `build-state`.

```clojure
(ns my.util)

(defn hook
  {:shadow.build/stage :flush}
  [build-state & args]
  (prn [:hello-world args])
  build-state)
```

--------------------------------

### Open File Command Execution Example (Emacsclient)

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Shows the command executed by shadow-cljs when emacsclient is configured for opening files, including line and column number formatting.

```bash
$ emacsclient -n +3:1 /path/to/project-root/src/main/demo/foo.cljs
```

--------------------------------

### EDN Configuration: Add Source Paths

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example of an EDN map snippet showing how to add source paths, with elided content.

```clojure
{...
 :source-paths ["src"]
 ...}
```

--------------------------------

### Manage Shadow-cljs Server Lifecycle

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Control the shadow-cljs server process using standard start, stop, and restart commands.

```bash
$ shadow-cljs start
```

```bash
$ shadow-cljs stop
```

```bash
$ shadow-cljs restart
```

--------------------------------

### EDN Configuration: Specify Dependencies

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example of an EDN map snippet for specifying project dependencies.

```clojure
{:dependencies [[lib "1.0"]]}
```

--------------------------------

### HTML to Load Shared and Main JS Files

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example HTML script tags for loading shared and main JavaScript files. Ensure shared.js is loaded before main.js.

```html
<script src="/js/shared.js"></script>
<script src="/js/main.js"></script>
```

--------------------------------

### Proto REPL Setup for ClojureScript in Atom

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configuration steps for using Proto REPL with ClojureScript in Atom. Requires a `user.clj` file, dependency addition, nREPL port configuration, and specific eval commands.

```clojure
(ns user)

 (defn reset [])
```

```clojure
(shadow.cljs.devtools.api/watch :your-build)
```

```clojure
(shadow.cljs.devtools.api/nrepl-select :your-build)
```

```clojure
(:repl/quit)
```

```clojure
(js/alert "foo")
```

--------------------------------

### Shadow-CLJS Configuration for Fireplace.vim

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configure shadow-cljs.edn to include CIDER-nREPL middleware and specify ports for the REPL and development HTTP servers. This setup is required for Fireplace.vim integration.

```clojure
;; shadow-cljs configuration
{:source-paths
 ["src/dev"
  "src/main"
  "src/test"]

 ;; ADD - CIDER-nREPL middleware required by Fireplace.vim
 :dependencies
 [[cider/cider-nrepl "0.22.4"]]

 ;; ADD - a port (e.g., 3333) for the REPL server to which Fireplace.vim connects
 :nrepl
 {:port 3333}

 ;; ADD - a port (e.g., 8080) for the development-time HTTP server that serves the app
 :dev-http
 {8080 "public"}

 :builds
 {:frontend  ; NOTE - This is the build ID referenced at various places below.
  {:target :browser
   :modules {:main {:init-fn acme.frontend.app/init}}}}}

```

--------------------------------

### Node Library Example

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Defines a ClojureScript namespace for a Node.js library. The build configuration specifies the output file and exports.

```clojure
(ns demo.lib)

(defn hello []
  (prn "hello")
  "hello")
```

```clojure
{... 
 :builds {:library {:target    :node-library
                    :output-to "out/demo-library/lib.js"
                    :exports   {:hello demo.lib/hello}}}}
```

--------------------------------

### Simplified Externs Example

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Defines properties that should not be renamed by the compiler. Global variables should be prefixed with 'global:'.

```text
# this is a comment
foo
bar
global:SomeGlobalVariable
```

--------------------------------

### JSX Pre-processing with Babel

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Illustrates how to pre-process JavaScript dialects like JSX using Babel. The example shows a minimal .babelrc configuration for React JSX.

```javascript
import React from "react";

function myComponent() {
  return <h1>JSX!</h1>;
}

export { myComponent };
```

```json
{
  "plugins": ["@babel/plugin-transform-react-jsx"]
}
```

--------------------------------

### Example of Dynamically Loaded Function

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

This is the function that might be loaded dynamically. It takes an event argument and returns a string.

```clojure
(ns demo.thing)
(defn x [e]
  "hello world")
```

--------------------------------

### Basic Development HTTP Server

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Serves static files from the 'public' directory on http://localhost:8000. This is a common setup for applications using browser push state.

```clojure
{... :dev-http {8000 "public"} :builds {...}}
```

--------------------------------

### Configure ESM Target with Module Exports

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Set up a build with the :esm target to generate JavaScript Modules. This example defines a module 'demo' with a specific export 'hello' from 'demo.lib'.

```clojure
{
 :source-paths ["src/main"]
 :dev-http {8000 "public"}
 :builds
 {:app
  {:target :esm
   :output-dir "public/js"
   :modules {:demo {:exports {hello demo.lib/hello}}}}}}
}
```

--------------------------------

### Configure Entry Keys for Package Resolution

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example configuration to prefer the 'module' entry over 'browser' and 'main' in package.json for resolving npm packages. This can be beneficial for modern packages providing ECMAScript modules.

```clojure
{... :builds {:app {:target :browser ... :js-options {:entry-keys ["module" "browser" "main"]} }}} ;; try "module" first
```

--------------------------------

### Running Shadow-cljs Tests with Karma

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Execute shadow-cljs compilation for the 'ci' build and start Karma in single-run mode to execute tests.

```bash
$ shadow-cljs compile ci
$ karma start --single-run
```

--------------------------------

### Configure :closure JS Provider for Browser Builds

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example configuration for using the :closure JS provider in a :browser build. This provider attempts to process included files via Closure Compiler for optimized output.

```clojure
{... :builds {:app {:target :browser ... :js-options {:js-provider :closure} }}}
```

--------------------------------

### Define a custom build function in Clojure

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Create a Clojure namespace with functions to manage builds and external processes. This example defines a `release` function that builds and then rsyncs output.

```clojure
(ns my.build
  (:require
    [shadow.cljs.devtools.api :as shadow]
    [clojure.java.shell :refer (sh)]))

(defn release []
  (shadow/release :my-build)
  (sh "rsync" "-arzt" "path/to/output-dir" "my@server.com:some/path"))
```

--------------------------------

### Supported #shadow/env forms

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Provides examples of different ways to use the #shadow/env reader tag for environment variable configuration, including defaults and type coercion.

```clojure
#shadow/env "APP_URL"
#shadow/env ["APP_URL"]
;; with default value, used if env variable is not set
#shadow/env ["APP_URL" "default-value"]
#shadow/env ["APP_URL" :default "default-value"]
;; turn PORT env into an integer, with default
#shadow/env ["PORT" :as :int :default 8080]
```

--------------------------------

### Connect to Build-Specific REPL via CLI

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Connects to a ClojureScript REPL for a specific build after starting a watch process. Requires a running watch process for the specified build ID.

```bash
$ shadow-cljs watch build-id
...

# different terminal
$ shadow-cljs cljs-repl build-id
shadow-cljs - connected to server
[3:1]~cljs.user=>
```

--------------------------------

### Configure deps.edn for shadow-cljs

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Add the shadow-cljs artifact to your deps.edn file. This example shows the basic structure for including shadow-cljs as a dependency.

```clojure
{:paths [...] 
 :deps {thheller/shadow-cljs {:mvn/version <latest>}}}
```

--------------------------------

### Run shadow-cljs watch via clj

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Execute the shadow-cljs watch command using the `clj` utility. This command starts a build process that watches for file changes.

```bash
clj -M:shadow-cljs watch app
```

--------------------------------

### Enable :deps true in shadow-cljs.edn

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Set the `:deps true` property in your shadow-cljs.edn configuration to enable tools.deps integration. This is a simple configuration example.

```clojure
{:deps true
 :builds ...}
```

--------------------------------

### Configure CIDER for shadow-cljs REPL with .dir-locals.el

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Simplifies shadow-cljs REPL startup by defining project-specific CIDER settings in a `.dir-locals.el` file. Use for a single build or multiple watched builds.

```emacs-lisp
((nil . ((cider-default-cljs-repl . shadow)
         (cider-shadow-default-options . "<your-build-name-here>"))))
```

```emacs-lisp
((nil . ((cider-default-cljs-repl . shadow)
         (cider-shadow-default-options . "<your-build-name-here>")
         (cider-shadow-watched-builds . ("<first-build>" "<other-build>")))))
```

--------------------------------

### Display Help Information

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Run this command to see all available shadow-cljs commands and their options.

```bash
$ ./node_modules/.bin/shadow-cljs help
```

--------------------------------

### Fireplace.vim REPL Connection Error

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

This error message appears in Fireplace.vim if the ClojureScript application has not been started and connected to the REPL server. Ensure the app is running before attempting to connect.

```text
No application has connected to the REPL server.
Make sure your JS environment has loaded your compiled ClojureScript code.

```

--------------------------------

### Externs Inference Warning Example

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example of a warning generated by the shadow-cljs compiler when it cannot infer the target type in an expression involving JavaScript interop.

```text
------ WARNING #1 --------------------------------------------------------------
 File: ~/project/src/demo/thing.cljs:23:3
--------------------------------------------------------------------------------
  21 |
  22 | (defn wrap-baz [x]
  23 |   (.baz x))
---------^----------------------------------------------------------------------
 Cannot infer target type in expression (. x baz)
--------------------------------------------------------------------------------

```

--------------------------------

### Basic shadow-cljs.edn Configuration

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

A minimal shadow-cljs.edn configuration file structure.

```clojure
{:source-paths [...] 
 :dependencies [...] 
 :builds {...}}
```

--------------------------------

### Configure Release Optimizations

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Specify Closure Compiler optimization levels within the :compiler-options section of the build configuration. This example sets the optimization level to ':simple'. Note that :optimizations are only applied during release builds.

```clojure
{...
 :build
   {:build-id
     {...
      :compiler-options {:optimizations :simple}}}}
```

--------------------------------

### Run a Release Build

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Execute a production-optimized release build for the specified application.

```bash
$ shadow-cljs release app
```

--------------------------------

### Define a Clojure function that requires a server

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Use the `{:shadow/requires-server true}` metadata to ensure a full shadow-cljs server instance is started when calling a function. This is necessary for functions like `shadow/watch`.

```clojure
(ns demo.run
  (:require [shadow.cljs.devtools.api :as shadow]))

;; this fails because a full server instance is missing
(defn foo
  [& args]
  (shadow/watch :my-build))

;; this metadata will ensure that the server is started so watch works
(defn foo
  {:shadow/requires-server true}
  [& args]
  (shadow/watch :my-build))
```

--------------------------------

### Configure Project Deps Aliases with User Config

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Combine project-specific and user-specific aliases for dependency resolution when using deps.edn. This example merges a project's :cljs alias with a user's :cider alias.

```clojure
;; shadow-cljs.edn in project
{:deps {:aliases [:cljs]}}

;; ~/.shadow-cljs/config.edn
{:deps-aliases [:cider]}
```

--------------------------------

### Configure React Resolution from Global Scope

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example configuration to resolve the 'react' npm package from a global JavaScript variable 'React', typically loaded via a CDN. The :server build continues to use the npm package.

```clojure
{... :builds {:app {:target :browser ... :js-options {:resolve {"react" {:target :global :global "React"}}}} :server {:target :node-script ... }}}
```

--------------------------------

### Basic Browser Build Configuration

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configures a browser build with a specified output directory and a main module entry point.

```clojure
{... :builds {:app {:target :browser :output-dir "public/js" ... :modules {:main {:entries [my.app]}}}}}
```

--------------------------------

### Browser Build with Init Function

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configures a browser build with an output directory and a main module that executes an initialization function upon loading.

```clojure
{... :builds {:app {:target :browser :output-dir "public/js" ... :modules {:main {:init-fn my.app/init}}}}}
```

--------------------------------

### Node.js HTTP Server with Hot Code Reload Hooks

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

This script demonstrates a basic HTTP server in Node.js with start and stop functions designed for hot code reload. Ensure the server is stored in a volatile reference to allow for stopping and restarting.

```clojurescript
(ns demo.script
  (:require ["http" :as http]))

(defn request-handler [req res]
  (.end res "foo"))

; a place to hang onto the server so we can stop/start it
(defonce server-ref
  (volatile! nil))

(defn main [& args]
  (js/console.log "starting server")
  (let [server (http/createServer #(request-handler %1 %2))]

    (.listen server 3000
      (fn [err]
        (if err
          (js/console.error "server start failed")
          (js/console.info "http server running"))
        ))

    (vreset! server-ref server)))

(defn start
  "Hook to start. Also used as a hook for hot code reload."
  []
  (js/console.warn "start called")
  (main))

(defn stop
  "Hot code reload hook to shut down resources so hot code reload can work"
  [done]
  (js/console.warn "stop called")
  (when-some [srv @server-ref]
    (.close srv
      (fn [err]
        (js/console.log "stop completed" err)
        (done)))))

(js/console.log "__filename" js/__filename)
```

--------------------------------

### Require react-table in ClojureScript

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example of how to require the 'react-table' library in a ClojureScript namespace. This works fine in the Browser targets.

```clojure
(ns my.app (:require ["react-table" :as rt]))
```

--------------------------------

### Basic Build Configuration

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

A configuration file with a build map, defining dependencies, source paths, and different build targets like 'app' for browser and 'tests' for karma.

```clojure
{:dependencies [[some-library "1.2.1"] ...]
 :source-paths ["src"]
 :builds
 {:app   {:target     :browser
          ... browser-specific options ...}
  :tests {:target :karma
          ... karma-specific options ...}}}
```

--------------------------------

### Configure SSL Keystore in shadow-cljs.edn

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Specify the keystore file and password for SSL configuration. If these defaults are used, an empty map `{}` is sufficient.

```clojure
{... :ssl {:keystore "ssl/keystore.jks" :password "shadow-cljs"} ...}
```

--------------------------------

### Command Line for Release Build with Version

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Command to perform a release build for the 'app' target and merge a release version configuration.

```bash
shadow-cljs release app --config-merge '{:release-version "v1"}'
```

--------------------------------

### Basic Function for Externs Inference Example

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

A simple ClojureScript function that demonstrates a potential scenario for externs inference warnings.

```clojure
(defn wrap-baz [x]
  (.baz x))

```

--------------------------------

### Connect to Build REPL

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Connect to the REPL for a specific build. This is typically available while a 'watch' build is running.

```bash
$ shadow-cljs cljs-repl app
```

--------------------------------

### Dummy project.clj for Leiningen Integration

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

A minimal project.clj file that can be used for Leiningen integration with shadow-cljs.

```clojure
(defproject your/project "0.0.0"
  :dependencies
  [[thheller/shadow-cljs "X.Y.Z"]]

  :source-paths
  ["src"])

```

--------------------------------

### Namespace Definition for a Module

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Define a namespace that can be exported by a shadow-cljs module. This example defines the 'foo' function for the 'demo.foo' namespace.

```clojure
(ns demo.foo)

(defn foo []
  (js/console.log "foo"))

```

--------------------------------

### Sample Worker Usage

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

This code initializes a web worker, sets up a message listener, and sends a message to the worker.

```clojure
(ns my.app)

(defn init []
  (let [worker (js/Worker. "/js/worker.js")]
    (.. worker (addEventListener "message" (fn [e] (js/console.log e))))
    (.. worker (postMessage "hello world"))))
```

--------------------------------

### Serve from Multiple Root Paths

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configures the development HTTP server to serve files from multiple specified root paths, checking them in order. Filesystem paths are relative to the project root, and classpath paths are searched on the classpath.

```clojure
:dev-http {8000 ["a" "b" "classpath:c"]}
```

--------------------------------

### Create Clojure Project using npx

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Command to create a new Clojure project directory with necessary basic files.

```bash
$ npx create-cljs-project my-project
```

--------------------------------

### Shadow-CLJS Help Command

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Command to display help information for shadow-cljs.

```bash
$ shadow-cljs help
```

--------------------------------

### Compile Build Directly via Leiningen

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Execute a compile task for a specific build ID using Leiningen, without starting a REPL or live-reload.

```bash
$ lein run -m shadow.cljs.devtools.cli compile build-id
```

--------------------------------

### Mark Namespace as Never Reloadable

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Tag a namespace with `:dev/once` metadata to ensure its code executes only once, even if recompiled. Useful for initialization or setup that should not be repeated.

```clojure
(ns ^:dev/once my.thing)

(js/console.warn "will only execute once")
```

--------------------------------

### Basic browser configuration

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

A minimal configuration for a browser build, specifying output directory, asset path, and module entries.

```clojure
{:dependencies [...] 
 :source-paths [...] 

 :builds
 {:app {:target :browser
        :output-dir "public/assets/app/js"
        :asset-path "/assets/app/js"
        :modules {:main {:entries [my.app]}}}}}
```

--------------------------------

### Redirect npm package for :node-script target

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configure shadow-cljs to use a different npm package when the target is :node-script. This example shows redirecting 'react' to 'preact-compat'.

```clojure
{... :builds {:app {:target :node-script ... :js-options {:resolve {"react" {:target :npm :require "preact-compat"}}}}}
```

--------------------------------

### List Dependencies with Leiningen (With Profile)

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Use this command to list dependencies when a specific Leiningen profile is active, as defined in shadow-cljs.edn. This ensures the correct dependency set is analyzed.

```bash
# with profile
$ lein with-profile +cljs deps :tree
```

--------------------------------

### List Dependencies with Leiningen (No Profile)

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

This command lists all dependencies managed by Leiningen without applying any specific profiles. Useful for initial dependency inspection.

```bash
# no profile
$ lein deps :tree
```

--------------------------------

### Serve Directory from Filesystem Root

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configures the development HTTP server to serve files directly from the specified directory on the filesystem.

```clojure
:dev-http {8000 "public"}
```

--------------------------------

### Example CLJS Code for Module Exports

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Defines a ClojureScript namespace with functions intended for export. Only 'hello' is exported, while 'not-exported' is internal and may be removed in release builds.

```clojure
(ns demo.lib)

(defn hello []
  (js/console.og "hello world"))

(defn not-exported []
  (js/console.log "foo"))

```

--------------------------------

### Connect Fireplace.vim to REPL Server

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Connect Fireplace.vim to the running nREPL server using the specified port. This command initiates the REPL session within Vim/Neovim.

```vim
:Connect 3333

```

--------------------------------

### Node.js Script Build Configuration

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Sample shadow-cljs build configuration for a Node.js script. Specifies the entry point and output file.

```clojure
{:source-paths [...] 
 ...
 :builds
 {:script
  {:target :node-script
   :main demo.script/main
   :output-to "out/demo-script/script.js"}}}
```

--------------------------------

### Convert PKCS12 to JKS Keystore

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Use the `keytool` utility to convert a PKCS12 keystore file (e.g., .p12 or .pfx) into the Java Keystore (JKS) format required by shadow-cljs.

```bash
$ keytool -importkeystore -destkeystore keystore.jks -srcstoretype PKCS12 -srckeystore localhost.pfx
```

--------------------------------

### React Native Build Configuration

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Minimal configuration for targeting React Native. Requires `:init-fn` for the application's startup function and `:output-dir` for build artifacts.

```clojure
{:source-paths [...] 
 :dependencies [...] 
 ...
 :builds
 {:app
  {:target :react-native
   :init-fn demo.app/init
   :output-dir "app"}}}

```

--------------------------------

### Configure nREPL Initialization Namespace

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Specify the initial namespace for the nREPL server when connecting. Defaults to `shadow.user`.

```clojure
{... :nrepl {:init-ns my.repl} ...}
```

--------------------------------

### Redirect npm package with :npm target

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configure shadow-cljs to use a different npm package than what is required by the code. This is useful for substituting dependencies, for example, using 'preact-compat' instead of 'react'.

```clojure
{... :builds {:app {:target :browser ... :js-options {:resolve {"react" {:target :npm :require "preact-compat"}}}}}
```

--------------------------------

### Multiple Source Paths Configuration

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configuring multiple source paths in shadow-cljs.edn to organize project files.

```clojure
{:source-paths ["src/main" "src/test"] 
 ...}
```

--------------------------------

### ClojureScript Code for Single Export

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Example ClojureScript code defining a function or a JS object that can be used as a single export for a Node.js library. This code should be referenced by the `:exports-var` configuration option.

```clojurescript
(ns demo.ns)

(defn f [...] ...)
;; OR
(def f #js {:foo ...})
```

--------------------------------

### Connect to Build-Specific REPL via Clojure REPL

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Initiates a shadow-cljs watch process and then connects to the ClojureScript REPL for a specific build. This method is used when already within a Clojure REPL.

```clojure
$ shadow-cljs clj-repl
...
[2:0]~shadow.user=> (shadow/watch :browser)
[:browser] Configuring build.
[:browser] Compiling ...
[:browser] Build completed. (341 files, 1 compiled, 0 warnings, 3,19s)
:watching
[2:0]~shadow.user=> (shadow/repl :browser)
[2:1]~cljs.user=>
```

--------------------------------

### Bash Command with Comment and Output

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Illustrates a typical bash command with a comment and its expected output, showing file listing.

```bash
# A comment. This command lists files:
$ ls -l
shadow-cljs.edn
project.clj
...
```

--------------------------------

### Configure Reader Features for Specific Builds

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Define :reader-features in compiler options to control which reader conditionals are active for a specific build. This example adds the :node reader feature to the :server build.

```clojure
{... :builds ;; app build configured normally, no adjustments required
 {:app
  {:target :browser
   ...}
  ;; for the server we add the :node reader feature
  ;; it will then be used instead of the default :cljs
  :server
  {:target :node-script
   :compiler-options
   {:reader-features #{:node}}}}}
```

--------------------------------

### Shim CLJSJS React Namespace

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Create a shim file to map 'cljsjs' namespaces to their original npm packages, enabling compatibility with libraries that rely on CLJSJS. This example shows how to shim the 'react' library.

```clojurescript
(ns cljsjs.react
  (:require ["react" :as react]
            ["create-react-class" :as crc]))
```

```clojurescript
(js/goog.object.set react "createClass" crc)
(js/goog.exportSymbol "React" react)
```

--------------------------------

### Open File Command Configuration (Idea)

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configuration for shadow-cljs to open files in the Idea IDE using a specific command structure. It uses a vector DSL where strings are literal and keywords are replaced by values like file path, line number, etc.

```clojure
{:open-file-command
 ["idea" :pwd "--line" :line :file]}
```

--------------------------------

### Karma Configuration File

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Set up the karma.conf.js file to run shadow-cljs tests. Specify browsers, output directory, test files, frameworks, plugins, and client arguments.

```javascript
module.exports = function (config) {
    config.set({
        browsers: ['ChromeHeadless'],
        basePath: 'target',
        files: ['ci.js'],
        frameworks: ['cljs-test'],
        plugins: ['karma-cljs-test', 'karma-chrome-launcher'],
        colors: true,
        logLevel: config.LOG_INFO,
        client: {
            args: ["shadow.test.karma.init"],
            singleRun: true
        }
    })
};
```

--------------------------------

### Shadow-cljs Server Startup Message

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

This message indicates the port the shadow-cljs server is running on. It defaults to 9630 and increments if the port is already in use.

```text
shadow-cljs - server running at http://0.0.0.0:9630
```

--------------------------------

### Handle No Connected Runtime Error

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Illustrates the error message when attempting to evaluate JavaScript in a ClojureScript REPL without a connected runtime (e.g., browser or Node.js process). Ensure your application is open in the browser or the Node.js process is started.

```clojure
[3:1]~cljs.user=> (js/alert "foo")
There is no connected JS runtime.
```

--------------------------------

### Load Module with Callback using shadow.loader

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Use `shadow.loader/with-module` to load a module and execute a callback function upon successful loading.

```clojure
(loader/with-module "extra" fn-to-call-on-load)
```

--------------------------------

### Node.js Script Entry Point

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Defines the main function for a Node.js script. This function will be called on startup with command line arguments.

```clojure
(ns demo.script)

(defn main [& cli-args]
  (prn "hello world"))
```

--------------------------------

### Launch ClojureScript REPL with CIDER

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Steps to launch an nREPL and ClojureScript REPL using CIDER in Emacs. Requires selecting 'shadow' as the REPL type and specifying the build target.

```shell
M-x cider-jack-in-cljs
```

```text
Select ClojureScript REPL type:

```

```text
Select shadow-cljs build:

```

```clojure
shadow.user> To quit, type: :cljs/quit
[:selected :app]
cljs.repl> 
```

```clojure
(js/alert "Jurassic Park!")
```

--------------------------------

### Default Cache Location Structure

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Illustrates the default directory structure for cache files, showing the path for a specific file within a build's cache.

```text
target/shadow-cljs/builds/app/dev/ana/cljs/core.cljs.cache.transit.json
```

--------------------------------

### Serve Directory from Classpath Root

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configures the development HTTP server to serve files from the classpath, looking for resources like 'public/index.html'. This can include files within .jar archives.

```clojure
:dev-http {8000 "classpath:public"}
```

--------------------------------

### Runtime Use of Node Library

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Demonstrates how to consume a compiled Node.js library from a JavaScript environment using `require`.

```shell
$ cd out/demo-library
$ node
> var x = require('./lib');
undefined
> x.hello()
hello
'hello'
```

--------------------------------

### Configure Leiningen Project for Shadow-cljs nREPL Middleware

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Integrate shadow-cljs nREPL middleware into a Leiningen project's REPL options to enable switching between Clojure and ClojureScript REPLs.

```clojure
(defproject my-amazing-project "1.0.0"
  ...
  :repl-options
  {:init-ns shadow.user ;; or any of your choosing
   :nrepl-middleware
   [shadow.cljs.devtools.server.nrepl/middleware]})
  ...)
```

--------------------------------

### Multiple Interop Calls with Type-Hint

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Demonstrates how to apply type hints to multiple JavaScript interop calls within a function.

```clojure
(defn wrap-baz [x]
  (.foo ^js x)
  (.baz ^js x))

```

--------------------------------

### Configure deps.edn for running shadow-cljs via clj

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Set up an alias in deps.edn to run shadow-cljs directly using the `clj` utility. This configures the main entry point for shadow-cljs.

```clojure
{:paths [...] 
 :deps {...} 
 :aliases
 {:shadow-cljs
  {:extra-deps {thheller/shadow-cljs {:mvn/version <latest>}}
   :main-opts ["-m" "shadow.cljs.devtools.cli"]}}}
```

--------------------------------

### Use environment variables in shadow-cljs.edn

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Illustrates how to use environment variables for configuration values within shadow-cljs.edn using the #shadow/env reader tag.

```clojure
{... 
 :builds
 {:app
  {:target :browser
   :output-dir "public/js"
   :closure-defines {your.app/URL #shadow/env "APP_URL"}
   ...}}}
```

--------------------------------

### Watch Directory Configuration

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

When not using the built-in HTTP server, specify the ':watch-dir' option to point to the document root for serving content. This is an alternative to ':dev-http'.

```clojure
{...
    {:builds
      {:app {...
             :devtools {:watch-dir "public"}}}}
```

--------------------------------

### Sample Echo Worker Implementation

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

A basic echo worker that listens for messages and posts them back.

```clojure
(ns my.app.worker)

(defn init []
  (js/self.addEventListener "message"
    (fn [^js e] 
      (js/postMessage (.. e -data)))))
```

--------------------------------

### List All Active Dependencies with tools.deps

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Use this command to list all dependencies managed by tools.deps, including transitive ones. This helps in identifying version conflicts.

```bash
$ clj -A:dev:cljs -Stree
```

--------------------------------

### Connect to Shadow-cljs nREPL Server

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Connect to the shadow-cljs nREPL server from Cursive using a Remote Run Configuration. Use the 'Use port from nREPL file' option.

```clojure
(shadow/repl :your-build-id)
```

--------------------------------

### Browser Test Build Configuration

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configuration for running tests in the browser. Includes dev-http for serving test files and a build target for browser tests.

```clojure
{
 ...
 ;; tests are served via http://localhost:8021
 :dev-http {8021 "out/test"}
 :builds
 {:test
  {:target :browser-test
   :test-dir  "out/test"}}}

```

--------------------------------

### Importing Specific Components from 'react-virtualized'

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Demonstrates importing specific named components from 'react-virtualized' using standard ES6 imports.

```javascript
// You can import any component you want as a named export from 'react-virtualized', eg
import { Column, Table } from 'react-virtualized'

// But if you only use a few react-virtualized components,
// And you're concerned about increasing your application's bundle size,
// You can directly import only the components you need, like so:
import AutoSizer from 'react-virtualized/dist/commonjs/AutoSizer'
import List from 'react-virtualized/dist/commonjs/List'
```

--------------------------------

### Open File Command Configuration (Emacsclient)

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configuration for shadow-cljs to open files in Emacs using emacsclient. It demonstrates using a format string for line and column numbers.

```clojure
{:open-file-command
 ["emacsclient" "-n" ["+%s:%s" :line :column] :file]}
```

--------------------------------

### Load a Module On-Demand with shadow.loader

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Use `shadow.loader/load` to asynchronously load a module. It returns a `goog.async.Deferred` which can be used like a promise.

```clojure
(ns my.app
  (:require [shadow.loader :as loader]))

(defn fn-to-call-on-load []
  (js/console.log "extra loaded"))

(defn fn-to-call-on-error []
  (js/console.log "extra load failed"))
```

```clojure
;; load returns a goog.async.Deferred, and can be used like a promise
(-> (loader/load "extra")
    (.then fn-to-call-on-load fn-to-call-on-error))
```

--------------------------------

### Configure ESM Target with :init-fn and Exports

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Combines ':init-fn' to run code automatically on module load with ':exports' to still make specific functions available for import and use.

```clojure
{
 :source-paths ["src/main"]
 :dev-http {8000 "public"}
 :builds
 {:app
  {:target :esm
   :output-dir "public/js"
   :modules
   {:demo
    {:init-fn demo.lib/hello
     :exports {hello demo.lib/hello}}}}}}
}
```

--------------------------------

### REPL Development Options

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configures REPL behavior within a build, specifying the initial namespace and enabling pretty-printing for evaluation results.

```clojure
{...
 :builds
 {:app {...
        :devtools {:repl-init-ns my.app
                   :repl-pprint true
                   ...}}}}
```

--------------------------------

### Compile a Build Once

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Use this command to perform a single compilation of a specified build and then exit.

```bash
$ shadow-cljs compile app
```

--------------------------------

### Shadow-cljs Build Configuration for Karma

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Configure shadow-cljs builds for CI environments using the :karma target. Specify the output file and a regex for test namespaces.

```clojure
{... :builds {:ci {:target :karma :output-to "target/ci.js" :ns-regexp "-spec$"}}}
```

--------------------------------

### Configure shadow-cljs.edn with :cljs alias

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Use the `:cljs` alias within your shadow-cljs.edn configuration. This allows for specific alias configurations.

```clojure
{:deps {:aliases [:cljs]}
 :builds ...}
```

--------------------------------

### Connect to Standalone Node REPL

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Connect to a REPL environment running in Node.js, independent of a browser build.

```bash
$ shadow-cljs node-repl
```

--------------------------------

### Configure Build Report via Build Hook

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Automatically generates a build report for every release build. The report is written to the :output-dir.

```clojure
{... 
 :builds
 {:app
  {:target :browser
   :output-dir "public/js"
   :modules ...
   :build-hooks
   [(shadow.cljs.build-report/hook)]
   }}}
}
```

--------------------------------

### Shadow-cljs Configuration for Node Library with Single Export

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

This configuration sets up a shadow-cljs build for a Node.js library using `:exports-var`. It specifies the output file and points to the ClojureScript var that will be exported as the default module export.

```clojure
{... 
 :builds {:lib {:output-to "lib.js"
                :exports-var demo.ns/f
                ...}}}
```

--------------------------------

### Configure Custom HTTP Port and Host

Source: https://shadow-cljs.github.io/docs/UsersGuide.html

Set a specific port and host for the primary HTTP server in `shadow-cljs.edn`. This allows overriding the default port selection mechanism.

```clojure
{... :http {:port 12345 :host "my.machine.local"} ...}
```
Tokens:
Raw