0.5.18 maintenance release

if the new nrepl is available start the server with it
only load nREPL dep if an :nrepl-port has been specified
remove single segment ns in namespace forms forms
allow :npm-deps to be true as well as false
added better error checking for missing ring handler
Clojure version comparison logic fix
change client side logging of a compile exception to a console.warning to support React Native better

0.5.17 new nREPL compatibility

Releasing this to support nREPL changes

fix how nREPL is required to support the new nrepl codebase
fix repl eval of namespace
some updated schema validations

0.5.16 Caching improvements & no trampoline on windows

Daniel Compton did some great work solving the caching issues.

There is also a very confusing problem with lein trampoline on Windows see issue #682. So I turned off the auto-trampoline feature for Windows which allowed the for the elegent use of Rebel readline by just calling lein figwheel.

Windows users can still elect to use trampoline with figwheel and get the benefits of rebel-readline but the will have to call lein trampoline figwheel and this should be done with the knowledge that they may experience a classpath corruption issue.

worker target support PR #659
important caching tweaks for serving CLJS assets PR #667
:npm-deps false support PR #678
fix to prefer and detect new cider/piggieback

0.5.15 Readline

A big thanks goes out to ClojuristsTogether.org and everyone who contributed for helping to make this work possible!

This release includes the biggest change that Figwheel has had in quite a while. After 2 months of work I'm proud to release a version of Figwheel that has Clojure readline support. Even if you always use your editor REPL like me, you may want to try the REPL that lein figwheel launches. You may find that its a handy tool to have around.

You can learn more about rebel-readline at https://github.com/bhauman/rebel-readline.

Don't forget this gets rid of the need for rlwrap.

You can disable the Rebel readline by adding :readline false to your :figwheel config.

This release requires that you use [org.clojure/clojurescript "1.9.946"] at least.

This release also, adds automatic support for projects that use Code Splitting. You should now be able to use code splitting and have Figwheel "just work".

Other changes:

Figwheel is now using cljs :preloads for figwheel client injection

0.5.14 Faster loading for complex dependency trees

Figwheel inherited a topo sort algorithm from the CLJS compiler. It turned out that this graph sorting algorithm missed a very important optimization, which is fixed in this release. If you have project that has a lot of namespaces and have experienced slower load times when you change a file that is deeper in your dependency chain, you should notice a big improvement when using this release.

Added JavaScript environment hooks for tools like re-natal to customize the websocket implementation and the script loading behavior.

improved topo-sort algorithm
CLJS compile option: the :entries key is no longer required in the :modules configs
new :repl-eval-timeout allows you to increase or lower the Figwheel REPL eval timeout as a top level config setting
added goog.global.FIGWHEEL_WEBSOCKET_CLASS to allow one to override or supply a websocket implementation for the figwheel client
added goog.global.FIGWHEEL_IMPORT_SCRIPT to allow one to override or supply a function to the figwheel client, that is responsible for loading a namespace into the JavaScript runtime.
added two new namespaces that can be supplied the ClojureScript compiler's :preloads option.

The two namespaces are only different in that one set's up figwheel while the other both sets up and starts figwheel. These are currently meant to clean up how the figwheel client is injected into the build. The next release of Figwheel will do away with generating a small ClojureScript file to inject the Figwheel client into build.
- figwheel.connect which will take a configuration from :external-tooling > :figwheel/config and supply a figwheel.connect/start function which contains the supplied config options. This function is exported so that it can be easily called from JavaScript.
- figwheel.preload which simply calls the above figwheel.connect/start function

0.5.13 Small updates

remove the use of a deprecated Google Closure library function goog.net.jsloader.load
add CLJS compile option :process-shim to validation code

0.5.12 Cache busting and more compiler option updates

There have been constant problems when reloading an application into Chrome where even a hard reload insists on pulling items from the cache. Adding no-cache to the response headers headers and returning appropriate not-modified responses is a trade-off that will hopefully address this issue without adversely affecting initial load performance. Keep in mind that this will only apply to Figwheel's built-in dev server. If this becomes a problem for some projects we can explore adding a flag for this behavior.

let :npm-deps use any named type for the keys
allow the server to serve symlinks outside of the project
take more care when checking localStorage for persistent config
add suspendable interface implementation to figwheel system component
add :checked-arrays option
update the catalog of :warning and :closure-warning options
fixes uses of aget
make configuration smiley paredit friendly

0.5.11 New cljs compiler options

add CLJS compile option :fn-invoke-direct to validation schema
add CLJS compile option :source-map-asset-path to validation schema
add CLJS compile option :load-test to validation schema
add CLJS compile option :npm-deps to validation schema
only watch directories if they exist - PR #551 fixes Issue #451

I knew when I started validating compiler options that there was a trade-off. On the one hand I can create really specific errors (i.e. spelling errors) if I do a hard check for key membership, but with the down side that as figwheel trails the compiler development new options would couse the config to fail validiation.

I figured this would be a good trade off considering that:

A. Compiler options will be added at a slower and slower rate as time goes on.

B. In general newer compiler options are geared towards more advanced users who understand the trade-off of opting-out of config validation.

One can opt-out/tune this behavior with the :validate-config option:

:validate-config (false | :warn-unknown-keys | :ignore-unknown-keys)

and skip unknown key validation all together.

0.5.10 Init and destroy hooks

In the top level figwheel config one can now place some lifecycle hooks, to easily add more services to the process that figwheel is running in.

For example:

:figwheel { :init    user/start-server
            :destroy user/stop-server }

Also:

loosen :clojure-defines validation

0.5.9 JavaScript reloading for Foreign lib dirs and pprint REPL results

seemless hot reloading of JavaScript in foreign lib dirs This works for the new Javascript module and pre-processing functionality introduced in CLJS 1.9.456
added pprint for repl eval results and tools to turn it on and off
display the number of connections in the REPL
support for webworkers added PR #498
send errors thrown when we try to reload a clojure file up to the HUD
added :compile-paths and :watch-paths
- :compile-paths will override :source-paths and determine the paths given to the compiler
- :watch-paths will override :source-paths and determine the paths given to the filewatcher
- :source-paths will always determine the paths to be added to the classpath
fix hot reloading on node for CLJS 1.9.456
support lein's managed dependencies
text-align left forced for the HUD displays
fixed css reloading race condition
fixed clj file reloading so that only macro files trigger reloads of CLJS dependents
fixed ^:figwheel-no-load
added :auto-clean option to allow the dissabling of figwheel's auto cleaning
reverted the inlining of figwheel connect cljs code and dump it to the filesystem
fixed (require) in the figwheel repl
fixed the reported output directory of a changed file
fix bug where figwheel connection scripts were being reloaded
clarify message when starting nrepl without piggieback
fix bugs around having :figwheel > :builds hold your build configs
:provides in :foreign libs is not a required option
added :infer-externs to schema
add cljs-config :closure-warnings to the config spec
add cljs-config :warnings to the config spec

0.5.8 Fix for Clojure 1.9.0-alpha12

small fix for recent Clojure alpha
vim-fireplace fix: merged #476 from Juho Teperi and Dominic Monroe

0.5.7 More small fixes

add :start to the :validate-interactive options
fix the cljs options modules spec
made the :open-urls feature work better

0.5.6 Small fix release

fixes issue #468 where hyphenated builds are failing to connect
fixes issue #467 where validation runs into an unparsable project.clj path

0.5.5 Config Validation with code context

added configuration validation based on clojure.spec
set :validate-interactive to false to prevent figwheel from entering validation correction loop
new options for :vaidate-config - besides the boolean option you can specify :warn-unknown-keys and :ignore-unknown-keys
new client option :auto-jump-to-source-on-error if set to true will cause the client to call the open-file-command script as soon as the heads up display displays an error or warning
setting :server-logfile to false will redirect all output to out
included a fix for vim-fireplace
heads-up error code context is now scrollable
make sure all output flows to out when :repl is false
ensure that all build :output-dir paramaters are unique
only make system calls for websocket-url format if they are required
the fighweel/connect.cljs is no longer output to disk but is passed to the compiler in memory
the generated connect code has a unique namespace depending on the build id
fixed google closure removal of dom/htmlToDocumentFragment
added on-cssload custom event

0.5.4-7 fix :open-command

PR #449 Arguments to open-file-command must be strings, not numeric.

0.5.4-6 update sidecar system apis to handle result of fetch-config

PR #447 change the validator to allow ES6 and :no-transpile
#440 allow figwheel system to take the result of (config/fetch-config)

0.5.4-5 quick fix

protecting against bad data broke Map style :builds declaration, fixed

0.5.4-4 added :preloads compiler option

Removed compojure as a dependency

Figwheel used Compojure in its server to handle routing. This was convenient but was also overkill for the simple routing that Figwheel needs. This also made the routing a bit more complex for the downstream :ring-handler.

Just recently a strange issue #428 popped up. Strange things where happening when wrap-reload was being used in an embedded :ring-handler.

There is so little routing functionality in Figwheel that I just replaced the Compojure routing with simple Ring middleware. This is much more predictable and has the added advantage of removing another dependency from Figwheel.

If the behavior of your :ring-handler changes (routes not being resolved, bad/missing HTTP headers etc.) please let me know.

For reference here is the commit: https://github.com/bhauman/lein-figwheel/commit/f027b10188ed9d1baa6ec04bbdd14e6a493f68b0

Improved the resiliency of the plugin around bad initial config data

The lein plugin uses config data from the project.clj (or figwheel.edn) before it has been validated, I added some extra safe guards to protect against initial use of this data.

added validation support for :preloads compiler option

0.5.4-3 some improvements around starting figwheel from the REPL

I added back figwheel-sidecar/get-project-builds which was removed in 0.5.4 its now here to stay.

Improved the expressiveness of (start-figwheel!)

before (start-figwheel!) only optionally took a configuration. Now it takes optional build-ids as well.

So you can do this:

(start-figwheel! "dev" "admin")

And it will pull in the config from the environment and start autobuilding the supplied build ids.

Or you can supply a config and build ids ...

(start-fighweel!
  {:figwheel-options {:server-port 4000}
   :all-builds [{:id ...}]}
   "dev" "admin")

I have also beefed up the error checking and feedback around this call.

0.5.4-2 Quick fix for failure due to composite lein profiles

my profile merging code was choking on composite lein profiles

0.5.4 Error messages and way more!

This is the most solid release of Figwheel so far ... enjoy!!

Code context in Errors and Warnings

This means you will see the compile errors and warnings displayed along with the offending code and a pointer to the position of the failure. This is a big improvement. I've found that even for simple errors, that I've become accustomed to, the new errors tend to beam the information into my head much more quickly.

The code pointers are rough at times and no code context information will be displayed if Figwheel doesn't get any line and column information from the compiler.

The new error display can be improved further, and I plan to do so. I just wanted to get the bits hooked up and a decent display out the door first.

added code context to compile errors in heads up display, figwheel_server.log and REPL output
added code context to compile warnings as well

Improved Build correctness

There have been several correctness problems that have dogged Figwheel for a while.

The most important change here is that I have made all code that runs in the plugin only depend on libs that are either natively available in Clojure or are included with Leiningen. This should rid us of the many ways that Figwheel was incompatible with other plugins and environments. I really had to learn the hard way that this is the only way to develop Leiningen plugins, and in hindsight, it makes a lot of sense.

A downside of this is that Figwheel "appears" to start slower. But all my tests have shown that it is starting slightly faster. And .... as a bonus lein trampoline works very well with Figwheel now.

If you are not already familiar with lein trampoline, the following command will cache the startup args the first time it is run, and will only launch one JVM on the next execution.

LEIN_FAST_TRAMPOLINE=y lein trampoline figwheel

In my setup I have the following script in on my path. Using it shaves seconds off of my startup time

file::/User/bhauman/bin/figt

#!/bin/bash

LEIN_FAST_TRAMPOLINE=y rlwrap lein trampoline figwheel "$@"

I have added startup and runtime checks to ensure that the various Figwheel library versions match.
I added a check to the client that will warn you if you are getting messages from a server that is a different version than the client.
Automatically clean a cljs build if the classpath changes or if the build :source-paths change or if certain ClojureScript compiler options change. This means that if you add a dependency in your project.clj the next time you start figwheel it will detect that change and clean out the build assets before compiling. If you have a simple classpath that points to a directory of jars this won't help you, but I think this will help a great majority of users.

DOA helper application

This is a user experience improvement experiment. There has been a problem when the initial compile fails and you open the browser and nothing happens and your REPL doesn't work.

Inspired by Elm, I am now emitting a small application that announces the problem when you load it in the browser. This application is a figwheel client so that it will respond to and display compilation messages and will provide a REPL execution environment.

It won't load compiled files but as soon as a compilation succeeds it will auto-refresh and thus pick up your correctly compiled application.

It's still early but I'm thinking that this could be a good feature.

Basic Leiningen profile merging

Folks who have been using (figwheel-start!) from the REPL have been confused by Figwheel's inability to merge in the default Leiningen profiles.

Figwheel will now merge Leiningen profiles without needing to load leiningen-core.

This behavior is new and not comprehensive but will probably work fine for the majority of cases where someone has a little profile merging in their project.clj

Added commands

The Figwheel lein plugin has added commands and better command-line feedback for bad args.

The new commands are

lein figwheel :once build-ids ...

Which will do what lein cljsbuild once does, with figwheel error messages. This command won't inject the figwheel client code.

lein figwheel :check-config

Which will run validation on your configuration.

lein figwheel :help

Which prints out the same help information as lein help figwheel

You should take a moment and read this help information.

Expect a :watch command in the next release....

Getting rid of `:build-options` in favor of `:compiler`

A younger, more idealistic version of myself, wanted to have a different key for compiler options. So I used :build-options internally. As usual that younger version of myself had no idea what he was doing.

If you are using :build-options you will get a validation error saying that it is deprecated and that you should use :compiler. :build-options is still being used internally but I am saving it as technical debt.

Lots more

huge configuration re-factor so that (start-figwheel!) now validates the configuration and throws useful exceptions if a configuration problem is found
fixed printing in the REPL, before you couldn't call (println "hi") and see the output in the REPL. This works for nREPL as well as a direct cljs.repl.
made printing much more robust, executing (js/setInterval #(println "hi") 1000) in the REPL works sending output to the REPL
fixed REPL js runtime stacktraces, these must have been broken for a while, sorry about that
a new :open-urls option in the per-build client :figwheel configuration. This is a vector of URLs that Figwheel will open the first time a build completes. These are opened with clojure.java.browse/browse-url. You could put http://cljs.info/cheatsheet/ info in there :)
fail fast if figwheel server doesn't start because of a port bind error
disable ansi colored output with :figwheel > :ansi-color-output false
figwheel now provides the :open-file-command script a third argument that is the column position of the problem. Yes this means that heads up display errors can pop you to the line and column if you click on them.
beefed up logging around :open-file-command so that one can debug it more easily
redirected :ring-handler exceptions and general printing output to the figwheel-server.log
ring exceptions and stack traces are displayed in the response HTML as well
fixed a problem where window.location was being called in a node environment
if you want to limit the classpath to only use the paths from the specified builds (i.e. builds supplied on the command line) you can set :figwheel > :load-all-builds false
removed awt beep from source code to remove the annoying Java system icons
fixed :repl false configuration option
fixed and improved (reload-config) REPL command, reports config errors now

0.5.3-2 Fix regression for initial build errors

cleaned up initial compile failure experience. There are horrendous errors if you start figwheel and you have a syntax error in your initial build. #fixes 392
hopefully fixed CustomEvent dispatch in IE Edge made
:source-map-timestamp default to true unless specifically set to false. This is for :figwheel builds only.
fixed a problem with :js-client-host, it now uses the localhost.hostname + server-port
Added :websocket-url template tags, see the Readme.
When reading raw project.clj extract data only from first form that starts with 'defproject

0.5.3-1 First take on improving compiler error messages

I'm planning on investing some time in fixing up the error messages. This is just a first take.

0.5.3

fail fast if trying to launch cljs REPL in nREPL environment and piggieback is not available fixes issue #347
passing :notify-command a more descriptive message, and call it on the very first build much more system notification friendly now, fixes PR #376
PR #369 added :server-hostname and :server-ip as options for build > :figwheel > :websocket-host this will insert host specific info to the figwheel client config
PR #371 added :closure-output-charset compiler option to config validation
moved to Clojure 1.8.0
add :nrepl-host to configuration validation
PR #363 print out actual server ip in "Figwheel: Starting server at"

0.5.2 Quick fix for Windows

fix null pointer because of bad resource path to config docs

0.5.1 Configuration Validation

added a fairly comprehensive configuration validation that is triggered when running 'lein figwheel' - there is a large surface area here so if you discover problems please report them

0.5.0-5 More work on system dependency conflicts

adding system asserts to ensure and warn if not using Java 1.8 or Clojure 1.7.0
adding polling option for hawk file watcher; just add :hawk-options {:watcher :polling} to base figwheel config
added friendlier 404 page

0.5.0-4

finally fixing the dependency conflicts

0.5.0-3

change repl-api commands like figwheel-start! so that they don't return the SystemMap as this was behaving badly in various REPL configurations 28e03af
figwheel-running? checks if figwheel is actually running now bb146e1
guard access to localStorage on client fdb49a2
Print exception when requiring ring handler fails f663acc
add support for notify-command back a475c59
Add exclusions to fix sidecar confusing dependencies b263835
For custom ring handler, bind to var, not to its value 789ff03
create directories for logfile ce39ac0

0.5.0-2

bumping http-kit to 0.2.19 get's rid of nasty exit exception
fix REPL helpers check for figwheel's running status
fixed REPL problem where pprint would produce extra output

0.5.0-1

added back figwheel-sidecar.repl/get-project-cljs-builds and deprecated
made the repl special-fn (build-once) work for builds that aren't opt none
made the repl special-fn (clean-builds) work for builds that aren't opt none

0.5.0 Complete Refactor

Figwheel is has undergone a large refactor and is now working better than ever
Figwheel is now internally composed of components and has been re-organized according to concerns - this is not quite finished yet so the internal api may be be unstable
this exposes the ability to compose component systems as you see fit and offering the ability to send messages from your own components to the figwheel client
moved to a FSEvent file watching strategy using the hawk library, this should ease CPU usage quite a bit
you can override the build function with the new :cljs-build-fn figwheel option
you can opt out of .clj or .cljc macro reloading
the build function follows a middleware strategy allowing you to splice in build time functionality
- this can easiliy allow you to skip all magic figwheel injections and just run straight cljs.build.api/build
hot loading javascript has been solidified even further
figwheel repl controls are much more sensible now, they alter a component system map
fixed various build config "parsing" problems
support for an external configuration file "figwheel.edn"
figwheel no longer overides :recompile-dependents default value bringing it inline with cljs compiler defaults
much much much more ...

0.4.1

fixed bug where GCL javascript modules with '-' in the namespace were not being hot reloaded
fixed Node.js support on windows (a path error ... who'd have guessed??)
improved the api for starting and stopping figwheel from scripts and such
added a way to quit out of the cljs-repl build choosing loop

0.4.0

:nrepl-middleware server configuration has been added (see readme) Thanks to Okke Thijhuis @otijhuis, give him a shout out!
both cider and piggieback have been removed, you must include the deps you want in your project.clj.
fix for #233: a stacktrace bug in the REPL
update string/replace usage, this could have affected REPL evaluations: thanks to @nikitonsky
make :ring-handler a var so it picks up changes - thanks to @nikitonsky
toggle auto loading on and off quickly with (figwheel.client/toggle-autoload) or figwheel.client.toggle_autoload() in the dev console

0.3.9

fixes incompatability with weasel and cljs browser repl

0.3.8

Incompatable with weasel repl and others that use the cljs browser repl. Expect a new release very soon.

Hot reloading Javascript! this works for :foreign-libs, :libs and Google Closure libs in your :source-paths that follow Clojure namespacing conventions - this is hot!
fixed the loading order of dependencies this silently broke a while back. Dependency loading has been overhauled to work with the latest CLJS and should be much more stable.
(require ... :reload) and (require ... :reload-all) work correctly now
adding :reload-dependents client config parameter. It forces the "reloading" of files that are dependent on changed files. This is very fast operation and can potentially obviate the need for ^:figwheel-always
removed cljsbuild as a dependency, this removes crossovers and notify-command from figwheel
new Community CLJS logo
fixing Node so that figwheel.connect works
added http PATCH to CORS

0.3.7

update to clojure 1.7.0!
hopefully fix #194 update http-kit

0.3.6

no change

0.3.5

small fixes to allow Atom.io usage see pr-188 and pr-189 for details
small devcards tweak

0.3.4

fix #183 htmlEscape warnings and errors in the heads up display
fix #179 add :server-ip server config option to all folks to not default to binding "0.0.0.0" which exposes the connection to the network
add :devcards option to figwheel client config, more on this later
add :websocket-host :js-client-host option to allow the client to use the location.host of the loaded page. Thanks to @peterschwarz
fix #180 cider no longer hard coded to repl, but auto detected, allows folks to use [cider-nrepl 0.9.0] a little more easily
making reloading of build config an explicit reload-config special-fn in the repl
fix #164 explicitly close the client side websocket on onload

0.3.3

ensure that we are only adding inserting the figwheel.connect require when :figwheel is set in the build

0.3.2

provide global custom events "figwheel.js-reload" and "figwheel.before-js-reload" for folks to hook into
initial build wasn't providing figwheel start hook to output-to file
merge PR #150 allow to configure binding host of nREPL
bump clojure requirement to be inline with clojurescript "0.1.7beta3" to fix #152
fix #151 stop depending on presence of project.clj
fix #147 handle presence of a deps.cljs on the source path
fix #145 cannot read property cljs$lang$maxFixedArity
merge PR #146 correctly detect if in html document

0.3.1

fixed regression on supporting map based build configs

0.3.0

the (reset-autobuild) REPL command now reloads the build config from your project.clj
simplified necessary build config parameters, no longer have to have :optimizations, :output-to, :output-dir

0.2.9

fixes #137 missing connect.cljs

0.2.8

vastly simplified configuration. You no longer need to write the client code manually and then figure out how to have it excluded in production. Simply add :fighweel true to builds that you want figwheel to run on. The client code will be injected to the build. You can inspect the generated client code in target/figwheel_temp/<build id>/fighweel/connect.cljs
fixed #126 where inclusion of figwheel.client in an advenced build caused "undefined is not a function" problems. This is fixed please don't include figwheel.client in advanced builds. It won't work.
fixed #124

0.2.7

support Reader Conditionals
require cljs-3165
re-fixed #118 topo-sort incorrect implementation
heads up display includes file and line information for reader exceptions
- Thanks to Juho Teperi

0.2.6

fixed shared compile-env for cljs-3196
fixed #108 double file loading
fixed #107 repl :false starts two compile processes
fixed #118 topo-sort incorrect implementation
fixed #106 empty build :id caused NPE
fixed #65 friendly error for already bound port error
upgraded cljsbuild
upgraded figwheel-sidecar dependencies

0.2.5

First non snapshot release
^:figwheel-always was causing a double file reload when editing the marked ns
minor fixes to be compatible with ClojureScript REPL changes
CSS changes broadast to all named builds, this should work fine as long as CSS files for different builds are named distinctly
fixed problem where using unquoted namespaces in :modules configurations was preventing figwheel from starting

0.2.5-SNAPSHOT

nREPL and cider support for the REPL adding an :nrepl-port along with a port number to the :figwheel config in your project.clj will start an nREPL server into the running figwheel process. https://github.com/bhauman/lein-figwheel/wiki/Using-the-Figwheel-REPL-within-NRepl
disabling hod loading for REPL only development Setting a new client side config option :autobuild to false will disable the automatic loading of code on file changes. Now that the cljs REPL development experience is maturing it's nice to have the option to do REPL only development. Its a client side option so that you can change back and forth between the styles of development fairly easily.

0.2.4-SNAPSHOT

adds source mapped stacktraces to REPL
does away dependents calculations when :recompile-dependents is false
corrects a complexity bug in calculating dependents
requires ClojureScript 0.0-2843 or greater

0.2.3-SNAPSHOT

Node.js support!: figwheel and the built-in REPL now supports running inside a Node.js evironment. This is very initial support for Node so if you run into trouble please let me know.
Possible Breaking Change: Figwheel now reloads files (js/css) from where they are originally loaded from. This should work in almost every setup imaginable. The :url-rewriter client config option shouldn't be needed in most cases now. If you are currently using :url-rewriter it will be broken as the form of the url argument is changing.
The above change means that you no longer are required to have your cljs target files on a resource path the figwheel server can see. If you are loading your app from the figwheel server the current :output-dir requirement still stands. If you are not going to load your app from the figwheel server then you you can place the files wherever you want.
node-webkit should also be much easier to use as a result of the above changes
Fully loads dependents: A new feature in the CLJS compiler is that it recompiles all files that are dependent on a changed .cljs file. Figwheel is complementing this behavior by doing the same: when a file changes all its dependents are loaded as well, in correct dependency order. This has the marvelous benefit of reloading the application root file whenever one of its dependencies change. This can obviate the need for :on-jsload but just having app restarting/rerendering code (like React.render) at the bottom of your root application file.
^:figwheel-always can now be added as meta data to cljs namespaces that you want to be reloaded whenever there is a file change in your source tree. With this flag you won't really need :on-jsload, even for complex setups. Namespaces marked figwheel-always do not have to be required. So you can put this on your test runner namespace and viola!, you will have your tests running in the client env on every reload. Pretty cool.
No more undefined errors in the REPL when you try to define things in the cljs.user ns after refreshing the browser.
better REPL support in general for (require :reload) and :reload-all
:debug is a new client config option, when it is truthy figwheel will print out copious amounts of debug information.
:load-unchanged-files is a client option that if set to false will cause the client to not reload files that haven't changed. With this option set to false files will only load if their content has changed. This option defaults to true.

0.2.2-SNAPSHOT

lein figwheel now launches a REPL into your application, this REPL shares the compilation environment with the autobuilder, this makes the REPL pretty darn intelligent about what is loaded in your browser env already. For ex. do (in-ns 'your.cljs.namespace) and poke around
for a better repl experience launch lein figwheel with rlwrap $ rlwrap lein figwheel you can install rlwrap on OSX with brew: brew install rlwrap
you can control the autobuild process from the CLJS REPL, no lein reboot
the repl can be disabled with :repl false in the :figwheel config
the logfile for figwheel server output can be configured with :server-logfile in :figwheel config
in 0.2.0 figwheel stopped honoring cljsbuild :notify-command, figwheel now honors :notify-command only on successful compiles, this should be especially helpful to those who are using :notify-command to run tests
requires org.clojure/clojurescript "0.0-2665" or greater

0.2.1-SNAPSHOT

now supports multiple builds i.e lein figwheel example example-admin
refactored figwheel-sidecar/auto-builder and clojurescript-build/auto a bunch to facilitate better reuse

0.2.0-SNAPSHOT

extremely fast incremental builds when editing Clojure (.clj) files
you can now call the figwheel autobuilder/change-server from the repl or your own build script (not documented yet)
isolated server and building code into to its own project to so that including the client code doesn't polute projects with clj based deps, the server and builder code only get's included in the plugin
fixed bug where warning handler was getting added over and over in the build loop
fixed bug: files that are't required don't get loaded but the console message was saying that they were
if you want to force an unrequired file to get loaded you can now do this (ns ^:figwheel-load example.core
if you want to prevent a file from being reloaded you can now do this (ns ^:figwheel-no-load example.setup

0.1.7-SNAPSHOT

compile warning notifications forwarded to client
block file reload if compile warnings are present (there is still a race condition in cljsbuild that prevents this from working 100% of the time) to overide this use :load-warninged-code true in the figwheel client
got rid of the defonce macro. It is built into cljs
added a heads up display to the client!!! You can opt out of this with :heads-up-display false in the client config
the heads up display 'can' trigger a file to open in your editor, if you do the work to get emacsclient or your editor's equivalent working correctly. In the :figwheel configuration in your project.clj you need to include an :open-file-command option. This should be the name of a script on your path that takes a file and a line number. The reccomendation here is to write your own script and put it in ~/bin.
:open-file-command is emacsclient aware so you can just provide "emacsclient" as an option and it will just work.
protection from connecting to another project by mistake
46 commits and many more changes
completely compatible with previous versions of figwheel unless you are using figwheel's defonce and not ClojureScripts

0.1.6-SNAPSHOT

better configuration validation and feedback for configuration errors
cleaned up, documented and added tests for plugin code
@font-face tags caused cors error, added promiscuous CORS support
added check for WebSocket support to prevent errors in IE8

0.1.5-SNAPSHOT

fixed windows path bug
made map based cljsbuild configurations work
fixed :http-server-root option

0.1.4-SNAPSHOT

Fixed LightTable incompatability
Figwheel now respects :resource-paths and you can have your compiled files in any resource path
Added :ring-handler configuration option to allow quck embedding of a dev server

Files

CHANGES.md

Latest commit

History