shadow.build.compiler — thheller/shadow-cljs 2.4.6

*cljs-warnings-ref* clj

*current-resource* clj

analyze clj

(analyze state compile-state form)

(analyze state {:keys [ns resource-name] :as compile-state} form repl-context?)

cache-affecting-options clj

compile-all clj

(compile-all {:keys [build-sources] :as state})

(compile-all {:keys [build-sources last-progress-ref] :as state} source-ids)

compile a list of sources by id, requires that the ids are in dependency order requires that ALL of the dependencies NOT listed are already compiled eg. you cannot just compile clojure.string as it requires other files to be compiled first

compile-cljs-seq clj

(compile-cljs-seq state compile-state cljs-forms)

compile-cljs-sources clj

(compile-cljs-sources {:keys [executor] :as state} sources non-cljs-provides)

compile-cljs-string clj

(compile-cljs-string state compile-state cljs-source)

copy-source-to-output clj

(copy-source-to-output state sources)

default-compile-cljs clj

(default-compile-cljs {:keys [last-progress-ref] :as state}
                      {:keys [ns macros-ns] :as compile-state}
                      form)

default-parse-ns clj

do-compile-cljs-resource clj

(do-compile-cljs-resource
  {:keys [compiler-options] :as state}
  {:keys [resource-id resource-name url file output-name] :as rc}
  source)

do-compile-cljs-string clj

(do-compile-cljs-string {:keys [resource-name cljc reader-features] :as init}
                        reduce-fn
                        cljs-source)

ensure-cache-invalidation-on-resolve-changes clj

(ensure-cache-invalidation-on-resolve-changes state resource-id)

populates :cache-key of the resource with the resolved symbols of its deps to ensure recompilation when their names change

generate-output-for-source clj

(generate-output-for-source state {:keys [resource-id type] :as src})

get-cache-file-for-rc clj

(get-cache-file-for-rc state {:keys [resource-name] :as rc})

hijacked-parse-ns clj

(hijacked-parse-ns env form rc opts)

is-cache-blocked? clj

(is-cache-blocked? state {:keys [ns requires macro-requires] :as rc})

load-cached-cljs-resource clj

(load-cached-cljs-resource {:keys [build-options] :as state}
                           {:keys [ns output-name resource-id resource-name]
                            :as rc})

load-core clj

(load-core)

make-cache-key-map clj

(make-cache-key-map state rc)

produces a map of {resource-id cache-key} for caching to identify whether a cache is safe to use (if any cache-keys do not match if is safer to recompile)

make-runtime-setup clj

(make-runtime-setup state)

maybe-closure-convert clj

(maybe-closure-convert {:keys [output] :as state} npm convert-fn)

maybe-compile-cljs clj

(maybe-compile-cljs {:keys [build-options previously-compiled] :as state}
                    {:keys [resource-id resource-name from-jar file url]
                     :as rc})

take current state and cljs resource to compile make sure you are in with-compiler-env

par-compile-cljs-sources clj

(par-compile-cljs-sources {:keys [executor] :as state}
                          sources
                          non-cljs-provides)

compile files in parallel, files MUST be in dependency order and ALL dependencies must be present this cannot do a partial incremental compile

par-compile-one clj

(par-compile-one {:keys [last-progress-ref] :as state}
                 ready-ref
                 errors-ref
                 {:keys [resource-id type requires provides] :as src})

post-analyze clj

(post-analyze {:keys [op] :as ast} build-state)

post-analyze-ns clj

(post-analyze-ns {:keys [name] :as ast} build-state)

remove-dead-js-deps clj

(remove-dead-js-deps {:keys [build-sources dead-js-deps] :as state})

seq-compile-cljs-sources clj

(seq-compile-cljs-sources state sources)

compiles with just the main thread, can do partial compiles assuming deps are compiled

shadow-emit clj multimethod

SHADOW-TIMESTAMP clj

throw-js-errors-now! clj

(throw-js-errors-now! state)

use-extern-properties clj

(use-extern-properties {:keys [js-properties] :as state})

warning-collector clj

(warning-collector build-env warnings warning-type env extra)

with-warnings clj/s macro

(with-warnings build-env & body)

given a body that produces a compilation result, collect all warnings and assoc into :warnings

write-cached-cljs-resource clj

(write-cached-cljs-resource state
                            {:keys [ns requires resource-id resource-name]
                             :as rc}
                            {:keys [warnings] :as output})