figwheel-sidecar.system — figwheel-sidecar 0.5.17

add-autobuilder clj

(add-autobuilder system build-id)

add-builds clj

(add-builds system build-configs)

add-css-watcher clj

(add-css-watcher system css-dirs)

add-initial-builds clj

(add-initial-builds {:keys [figwheel-server] :as system} build-ids)

add-nrepl-server clj

(add-nrepl-server system {:keys [nrepl-port] :as options})

all-build-keys clj

(all-build-keys system)

build-config->key clj

build-diff clj

(build-diff system ids)

Makes sure that the autobuilds in the system match the build-ids provided

build-figwheel-special-fns clj

(build-figwheel-special-fns system)

build-key? clj

(build-key? k)

build-once clj

(build-once system ids)

Builds the given ids or the current builds once

build-switching-cljs-repl clj

(build-switching-cljs-repl figwheel-system)

(build-switching-cljs-repl figwheel-system start-build-id)

(build-switching-cljs-repl {:keys [system]} start-build-id repl-options)

build-switching-cljs-repl* clj

(build-switching-cljs-repl* system start-build-id repl-options)

choose-repl-build clj

(choose-repl-build system build-id)

choose-repl-build-id clj

(choose-repl-build-id system)

clean-builds clj

(clean-builds system ids)

Deletes the compiled assets for the given ids or cleans all the current autobuilds. This command stops and starts the autobuilds.

clear-compiler-env-for-build-id clj

(clear-compiler-env-for-build-id system build-id)

cljs-repl clj

(cljs-repl & args)

cljs-repl* clj

(cljs-repl* system)

(cljs-repl* system start-build-id)

(cljs-repl* system start-build-id repl-options)

create-figwheel-system clj

(create-figwheel-system config-data)

This creates a complete Figwheel only system. It conditionally adds a CSS watcher if the configuration contains :css-dirs and conditionally adds an nREPL server component if the Figwheel configuration contains an :nrepl-port key.

This takes a figwheel configuration consisting of :figwheel-options, :all-builds, and :build-ids.

If you only have a few components to add to this system then you can assoc them onto the created system before you start like so.

(def my-system (assoc (create-figwheel-system (config/fetch-config)) :html-reload (component/using (html-reloader {:watch-paths ["resources/public"]}) [:figwheel-system]) :web-server (my-webserver-component)))

css-watcher clj

(css-watcher opts)

dispatch-system-component-errors clj

(dispatch-system-component-errors component-control-fn)

fetch-config clj

fetch-config-print-errors clj

(fetch-config-print-errors)

fig-status clj

(fig-status system)

Prints out the status of the running figwheel system

figwheel-cljs-repl clj

(figwheel-cljs-repl figwheel-system)

(figwheel-cljs-repl figwheel-system build-id)

(figwheel-cljs-repl {:keys [system]} build-id repl-options)

figwheel-cljs-repl* clj

(figwheel-cljs-repl* system build-id repl-options)

figwheel-repl-options clj

(figwheel-repl-options repl-options system)

figwheel-system clj

(figwheel-system config-data)

get-build-choice clj

(get-build-choice choices)

get-builds-to-start clj

(get-builds-to-start figwheel-server build-ids)

get-project-builds clj

(get-project-builds)

id->build-config clj

(id->build-config system id)

id->key clj

ids-or-all-build-keys clj

(ids-or-all-build-keys system ids)

ids-or-all-build-keys* clj

(ids-or-all-build-keys* system ids)

initial-repl-focus-build-id clj

(initial-repl-focus-build-id system)

key->id clj

(key->id build-key)

make-special-fn clj

(make-special-fn f)

namify clj

(namify arg)

nrep-server-component clj

parse-start-figwheel-args clj

(parse-start-figwheel-args args)

patch-system-builds clj

(patch-system-builds system ids)

print-config clj

(print-config system ids)

Prints out the build config for the given ids or all the build configs

reload-config clj

(reload-config system)

Resets the system and reloads the the confgiguration as best it can.

repl-env clj

(repl-env & args)

repl-env* clj

(repl-env* system)

(repl-env* system start-build-id)

(repl-env* system start-build-id repl-options)

repl-function-docs clj

reset-autobuild clj

(reset-autobuild system)

Alias for clean-builds

running-versus-not-running clj

(running-versus-not-running system ids)

start-autobuild clj

(start-autobuild system ids)

Either starts all the current autobuilds or adds the supplied build and starts autobuilding it.

start-figwheel! clj

(start-figwheel! & args)

This function will start the figwheel system.

(start-figwheel!)

If called with no arguments it will load and validate the configuration found in your project.clj or a figwheel.edn file in the root of your project. If there is a figwheel.edn file any configuration information found in the project.clj will be ignored.

(start-figwheel! "example" "example-admin" ...)

You can also supply the build ids that you want figwheel to start autobuilding. If these ids aren't available in the builds specified in the found configuration this function will throw an error.

(start-figwheel! ;; using the configuration shape of figwheel.edn {:server-port 5000 :builds [{:id ...}]}

(start-figwheel! ;; using the configuration shape of figwheel.edn {:server-port 5000 :builds (figwheel-sidecar.config/get-project-builds) :builds-to-start ["example"]})

(start-figwheel! ;; using the soon to be deprecated legacy configuration shape {:figwheel-options { :server-port 4000 } :all-builds [{:id ...}] :build-ids ["example"]})

As seen above you can also directly supply a configuration Map that has the shape of a figwheel.edn file or the legacy format which will be deprecated in the near future.

(start-figwheel! (figwheel-sidecar.config/fetch-config) "example" "example-admin")

After supplying a configuration, you can also list the build-ids that you would like to start.

start-figwheel!* clj

(start-figwheel!* config-options build-ids)

start-figwheel-and-cljs-repl! clj

(start-figwheel-and-cljs-repl! autobuild-options)

start-figwheel-repl clj

(start-figwheel-repl system build repl-options)

start-figwheel-system clj

(start-figwheel-system {:keys [figwheel-options all-builds build-ids]
                        :as options})

start-repl clj

(start-repl start-fn figwheel-system)

(start-repl start-fn figwheel-system start-build-id)

(start-repl start-fn {:keys [system]} start-build-id repl-options)

stop-and-start-watchers clj

(stop-and-start-watchers system build-ids thunk)

stop-autobuild clj

(stop-autobuild system ids)

Stops autobuilding the specific ids or all currently running autobuilds

stop-figwheel! clj

(stop-figwheel! system)

switch-to-build clj

(switch-to-build system ids)

Switches autobuilding from the current autobuilds to the given build ids

system-remove clj

(system-remove system ids)

Remove the ids from the system

system-setter clj

(system-setter func system-atom)

unwrap-component-exception clj

(unwrap-component-exception e)

use-color? clj

(use-color? system)

valid-key? clj

(valid-key? system key)

watchers-running clj

(watchers-running system)