cljs.compiler — org.clojars.pmbauer/clojurescript_svced 1.0.0-SNAPSHOT

*inputs* clj

*lexical-renames* clj

*recompiled* clj

*source-map-data* clj

*source-map-data-gen-col* clj

all-distinct? clj

(all-distinct? xs)

base-types clj

cached-core clj

(cached-core ns ext opts)

checking-types? clj

(checking-types?)

cljs-files-in clj

(cljs-files-in dir)

Return a sequence of all .cljs and .cljc files in the given directory.

cljs-reserved-file-names clj

compile-file clj

(compile-file src)

(compile-file src dest)

(compile-file src dest opts)

Compiles src to a file of the same name, but with a .js extension, in the src file's directory.

With dest argument, write file to provided location. If the dest argument is a file outside the source tree, missing parent directories will be created. The src file will only be compiled if the dest file has an older modification time.

Both src and dest may be either a String or a File.

Returns a map containing {:ns .. :provides .. :requires .. :file ..}. If the file was not compiled returns only {:file ...}

compile-file* clj

(compile-file* src dest)

(compile-file* src dest opts)

compile-root clj

(compile-root src-dir)

(compile-root src-dir target-dir)

(compile-root src-dir target-dir opts)

Looks recursively in src-dir for .cljs files and compiles them to .js files. If target-dir is provided, output will go into this directory mirroring the source directory structure. Returns a list of maps containing information about each file which was compiled in dependency order.

compiled-by-string clj

(compiled-by-string)

(compiled-by-string opts)

distinct-constants? clj

(distinct-constants? items)

distinct-keys? clj

(distinct-keys? keys)

emit clj

(emit ast)

emit* clj multimethod

emit-apply-to clj

(emit-apply-to {:keys [name params env]})

emit-arguments-to-array clj

(emit-arguments-to-array startslice)

Emit code that copies function arguments into an array starting at an index. Returns name of var holding the array.

emit-cached-core clj

(emit-cached-core src dest cached opts)

emit-comment clj

(emit-comment doc jsdoc)

(emit-comment env doc jsdoc)

Emit a nicely formatted comment string.

emit-constant clj

(emit-constant v)

emit-constant* clj multimethod

emit-constant-no-meta clj

(emit-constant-no-meta x)

emit-constants-comma-sep clj

(emit-constants-comma-sep cs)

emit-constants-table clj

(emit-constants-table table)

emit-constants-table-to-file clj

(emit-constants-table-to-file table dest)

emit-dot clj

(emit-dot {:keys [target field method args env]})

emit-externs clj

(emit-externs externs)

(emit-externs prefix externs top-level known-externs)

emit-fn-method clj

(emit-fn-method {expr :body :keys [type name params env recurs]})

emit-fn-params clj

(emit-fn-params params)

emit-global-export clj

(emit-global-export ns-name global-exports lib)

emit-inferred-externs-to-file clj

(emit-inferred-externs-to-file externs dest)

emit-js-array clj

(emit-js-array items comma-sep)

emit-js-object clj

(emit-js-object items emit-js-object-val)

emit-let clj

(emit-let {expr :body :keys [bindings env]} is-loop)

emit-list clj

(emit-list items comma-sep)

emit-map clj

(emit-map keys vals comma-sep distinct-keys?)

emit-record-value clj

(emit-record-value ns name items)

emit-set clj

(emit-set items comma-sep distinct-constants?)

emit-source clj

(emit-source src dest ext opts)

emit-source-map clj

(emit-source-map src dest sm-data opts)

emit-str clj

(emit-str expr)

emit-var clj

(emit-var {:keys [info env form] :as ast})

emit-variadic-fn-method clj

(emit-variadic-fn-method {expr :body
                          max-fixed-arity :fixed-arity
                          variadic :variadic?
                          :keys [type name params env recurs]
                          :as f})

emit-vector clj

(emit-vector items comma-sep)

emit-with-meta clj

(emit-with-meta expr meta)

emit-wrap clj macro

(emit-wrap env & body)

emitln clj

(emitln)

(emitln a)

(emitln a b)

(emitln a b c)

(emitln a b c d)

(emitln a b c d e)

(emitln a b c d e & xs)

emits clj

(emits)

(emits a)

(emits a b)

(emits a b c)

(emits a b c d)

(emits a b c d e)

(emits a b c d e & xs)

emits-keyword clj

(emits-keyword kw)

emits-symbol clj

(emits-symbol sym)

falsey-constant? clj

(falsey-constant? expr)

find-ns-starts-with clj

(find-ns-starts-with needle)

find-root-sources clj

(find-root-sources src-dir)

find-source clj

(find-source file)

fn-self-name clj

(fn-self-name {:keys [name info] :as name-var})

get-define clj

(get-define mname jsdoc)

get-first-ns-segment clj

(get-first-ns-segment ns)

Gets the part up to the first . of a namespace. Returns the empty string for nil. Returns the entire string if no . in namespace

hash-scope clj

(hash-scope s)

js-reserved clj

load-libs clj

(load-libs libs seen reloads deps ns-name)

macro-ns? clj

(macro-ns? ns ext opts)

mapped-types clj

munge clj

(munge s)

(munge s reserved)

munge-param-return clj

(munge-param-return env line)

munge-reserved clj

(munge-reserved reserved)

protocol-prefix clj

(protocol-prefix psym)

rename-to-js clj

(rename-to-js file-str)

Change the file extension from .cljs to .js. Takes a File or a String. Always returns a String.

requires-compilation? clj

(requires-compilation? src dest)

(requires-compilation? src dest opts)

Return true if the src file requires compilation.

resolve-type clj

(resolve-type env t)

resolve-types clj

(resolve-types env ts)

safe-test? clj

(safe-test? env e)

shadow-depth clj

(shadow-depth s)

truthy-constant? clj

(truthy-constant? expr)

url-path clj

(url-path f)

valid-define-value? clj

(valid-define-value? x)

with-core-cljs clj

(with-core-cljs)

(with-core-cljs opts)

(with-core-cljs opts body)

Ensure that core.cljs has been loaded.