applied-science.js-interop — applied-science/js-interop 0.4.2

cljs

A JavaScript-interop library for ClojureScript.

!assoc-in! clj/s macro

(!assoc-in! obj ks v)

!get clj/s macro

(!get & args)

!get-in clj/s macro

(!get-in obj ks)

!set clj/s macro

(!set obj & keyvals)

!update clj/s macro

(!update obj k f & args)

apply clj/s≠

(apply obj k arg-array)

cljs

Apply function k of obj, binding this to obj.

(j/apply o :someFunction #js [arg1 arg2])
(j/apply o .-someFunction #js [arg1 arg2])

apply-in clj/s≠

(apply-in obj ks arg-array)

cljs

Apply function nested at path with arg-array, binding this to its parent object.

(j/apply-in o [:x :someFunction] arg1 arg2)

apply-to-bodies clj

(apply-to-bodies f expr)

For recursive lit*, ignores known clj syntax

assoc! clj/s≠

(assoc! obj & keyvals)

cljs

Sets key-value pairs on obj, returns obj.

(j/assoc! o :x 10)
(j/assoc! o .-x 10)

assoc-in! clj/s≠

(assoc-in! obj ks v)

cljs

Mutates the value in a nested object structure, where ks is a sequence of keys and v is the new value. If any levels do not exist, objects will be created.

(j/assoc-in! o [:x :y] 10)
(j/assoc-in! o [.-x .-y] 10)

call clj/s≠

clj

(call k)

(call obj k & args)

cljs

(call obj k & args)

Call function k of obj, binding this to obj.

(j/call o :someFunction arg1 arg2)
(j/call o .-someFunction arg1 arg2)

call-in clj/s≠

(call-in obj ks & args)

cljs

Call function nested at path with args, binding this to its parent object.

(j/call-in o [:x :someFunction] arg1 arg2)

clj-lit clj

(clj-lit x)

lit for Clojure target, only handles ~@unquote-splicing

contains? clj/s≠

(contains? obj k)

cljs

Returns true if obj contains k.

(j/contains? o :k)
(j/contains? o .-k)

defn clj/s macro

(defn & args)

defn with argument destructuring that supports js property and array access. Use ^:js metadata on binding forms to invoke.

delete! clj/s macro

(delete! obj k)

expand clj/s macro

(expand expr)

extend! cljs

(extend! obj)

(extend! obj x)

(extend! obj x & more)

alias for merge!

fn clj/s macro

(fn & args)

fn with argument destructuring that supports js property and array access. Use ^:js metadata on binding forms to invoke. Eg/

(fn [^:js {:keys [a]}] …)

get clj/s≠

(get k)

(get obj k)

(get obj k not-found)

cljs

Returns the value mapped to key, not-found or nil if key not present.

(j/get o :k)
(j/get o .-k)

get-in clj/s≠

(get-in ks)

(get-in obj ks)

(get-in obj ks not-found)

cljs

Returns the value in a nested object structure, where ks is a sequence of keys. Returns nil if the key is not present, or the not-found value if supplied.

(j/get-in o [:x :y] :fallback-value)
(j/get-in o [.-x .-y] :fallback-value)

if-let clj/s macro

(if-let bindings then)

(if-let bindings then else)

in? clj/s macro

(in? k obj)

js-defn clj/s macro

(js-defn & args)

js-fn clj/s macro

(js-fn & args)

js-if-let clj/s macro

(js-if-let bindings & args)

js-let clj/s macro

(js-let bindings & body)

js-when-let clj/s macro

(js-when-let bindings & body)

let clj/s macro

(let bindings & body)

let with destructuring that supports js property and array access. Use ^:js metadata on the binding form to invoke. Eg/

(let [^:js {:keys [a]} obj] …)

lit clj/s macro

(lit form)

Recursively converts literal Clojure maps/vectors into JavaScript object/array expressions (using j/obj and cljs.core/array)

lit* clj

(lit* x)

(lit*
  {:as opts :keys [keyfn valfn env deep?] :or {keyfn identity valfn litval*}}
  x)

Recursively converts literal Clojure maps/vectors into JavaScript object/array expressions

Options map accepts a :keyfn for custom key conversions.

litval* clj

(litval* v)

log clj/s macro

(log & args)

js/console.log

lookup cljs

(lookup obj)

Wraps obj with an ILookup implementation, to support reading/destructuring. Does not support renamable keys.

(let [{:keys [a b c]} (j/lookup o)]
 ...)

merge! cljs

(merge! obj)

(merge! obj x)

(merge! obj x & more)

Extends obj with the properties of one or more objects, overwriting existing properties, moving left to right. Returns obj. An empty starting object is provided if obj is nil.

(j/extend! o other)
(j/extend! o other #js{:x 1})

Not IE6-friendly

obj clj/s≠

(obj & keyvals)

cljs

Create JavaScript object from an even number arguments representing interleaved keys and values.

(obj :a 1 :b 2 .-c 3 .-d 4)

push! clj/s≠

clj

(push!)

(push! array)

(push! array v)

cljs

(push!)

(push! array)

(push! array x)

Appends v to array and returns the mutated array.

(j/push! arr 10)

select-keys clj/s≠

(select-keys obj ks)

cljs

Returns an object containing only those entries in o whose key is in ks.

(j/select-keys o [:a :b :c])
(j/select-keys o [.-a .-b .-c])

some-or clj/s macro

(some-or x y)

Like or but switches on some? instead of truthiness.

tag-js clj

(tag-js x)

unchecked-get clj/s≠

clj

(unchecked-get obj k)

(unchecked-get obj k not-found)

cljs

(unchecked-get obj k)

unchecked-set clj/s

(unchecked-set obj & keyvals)

unshift! clj/s≠

clj

(unshift! array v)

cljs

(unshift! array x)

Prepends v to a and returns the mutated array.

(j/unshift! arr 10)

update! clj/s≠

(update! obj k f & args)

cljs

'Updates' a value in a JavaScript object, where k is a key and f is a function that will take the old value and any supplied args and return the new value, which replaces the old value. If the key does not exist, nil is passed as the old value.

(j/update! o :a + 10)
(j/update! o .-a + 10)

update-in! clj/s≠

(update-in! obj ks f & args)

cljs

'Updates' a value in a nested object structure, where ks is a sequence of keys and f is a function that will take the old value and any supplied args and return the new value, mutating the nested structure. If any levels do not exist, objects will be created.

(j/update-in! o [:x :y] + 10)
(j/update-in! o [.-x .-y] + 10)

update-keys! cljs

(update-keys! obj f)

update-vals! cljs

(update-vals! obj f)

when-let clj/s macro

(when-let bindings & body)