shadow.cljs.devtools.api — thheller/shadow-cljs 2.4.5

*nrepl-active* clj

*nrepl-clj-ns* clj

*nrepl-cljs* clj

*nrepl-quit-signal* clj

active-builds clj

(active-builds)

browser-repl clj

(browser-repl)

(browser-repl {:keys [verbose open] :as opts})

build-finish clj

(build-finish {:shadow.build/keys [build-info] :as state} config)

check clj

(check build)

(check build opts)

check* clj

(check* {:keys [id] :as build-config} opts)

compile clj

(compile build)

(compile build opts)

compile! clj

(compile! build opts)

do not use at the REPL, will return big pile of build state, will blow up REPL by printing too much

compile* clj

(compile* build-config opts)

compiler-env clj

(compiler-env build-id)

dev clj

(dev build)

(dev build opts)

dev* clj

(dev* {:keys [build-id] :as build-config} {:keys [autobuild verbose] :as opts})

find-resources-using-ns clj

(find-resources-using-ns ns)

get-build-config clj

(get-build-config id)

get-build-ids clj

(get-build-ids)

get-config clj

(get-config)

get-runtime! clj

(get-runtime!)

get-server-addr clj

(get-server-addr)

get-worker clj

(get-worker id)

help clj

(help)

make-runtime clj

(make-runtime)

node-repl clj

(node-repl)

(node-repl opts)

nrepl-select clj

(nrepl-select id)

(nrepl-select id {:keys [skip-repl-out] :as opts})

once clj

(once build)

(once build opts)

deprecated: use compile

release clj

(release build)

(release build opts)

release* clj

(release* build-config {:keys [debug source-maps pseudo-names] :as opts})

release-snapshot clj

(release-snapshot & args)

repl clj

(repl build-id)

(repl build-id {:keys [stop-on-eof] :as opts})

repl-client-connected? clj

(repl-client-connected? worker)

repl-next clj

(repl-next build-id)

(repl-next build-id {:keys [stop-on-eof] :as opts})

select-cljs-runtime clj

(select-cljs-runtime worker)

start-browser-repl* clj

(start-browser-repl* {:keys [config supervisor] :as app})

stop-worker clj

(stop-worker build-id)

test clj

(test)

watch clj

(watch build-id)

(watch build-id opts)

starts a dev worker process for a given :build-id opts defaults to {:autobuild true}

watch* clj

(watch* {:keys [build-id] :as build-config}
        {:keys [autobuild verbose sync] :as opts})

watch-compile! clj

(watch-compile! build-id)

manually trigger a recompile for a watch when {:autobuild false} is used

watch-compile-all! clj

(watch-compile-all!)

call watch-compile! for all running builds

watch-set-autobuild! clj

(watch-set-autobuild! build-id toggle)

starts/stops autobuild for a watch worker by id (watch-set-autobuild :app true|false)

with-runtime clj/s macro

(with-runtime & body)

worker-running? clj

(worker-running? build-id)