dommy.core — prismatic/dommy 1.1.0

cljs

Core DOM manipulation functions

add-class! cljs

(add-class! elem classes)

(add-class! elem classes & more-classes)

Add classes to elem, trying to use Element::classList, and falling back to fast string parsing/manipulation

ancestor-nodes cljs deprecated

ancestors cljs

(ancestors elem)

Lazy seq of the ancestors of elem

append! cljs

(append! parent child)

(append! parent child & more-children)

Append child to parent

attr cljs

(attr elem k)

bounding-client-rect cljs

(bounding-client-rect elem)

Returns a map of the bounding client rect of elem as a map with [:top :left :right :bottom :width :height]

by-class clj/s macro

(by-class class)

(by-class base class)

Returns a sequence of DOM nodes selected by class. class can be a string or keyword and should not include the . selector prefix. Expands to base.getElementsByClassName. If base node is given, selection is limited to its descendant nodes.

by-id clj/s macro

(by-id id)

Returns the DOM node with id in document if it exists, otherwise nil. id can be a string or keyword. Expands to document.getElementById.

by-tag clj/s macro

(by-tag tag)

(by-tag base tag)

Same behavior as by-class, selecting by tag instead of a class.

children cljs

(children elem)

class cljs

(class elem)

clear! cljs

(clear! elem)

Clears all children from elem

closest cljs

(closest elem selector)

(closest base elem selector)

Closest ancestor of elem (up to base, if provided) that matches selector

create-element cljs

(create-element tag)

(create-element tag-ns tag)

create-text-node cljs

(create-text-node text)

descendant? cljs

(descendant? descendant ancestor)

Is descendant a descendant of ancestor? (http://goo.gl/T8pgCX)

has-class? cljs

(has-class? elem c)

Does elem contain c in its class list

hidden? cljs

(hidden? elem)

Is elem hidden (as associated with hide!/show!/toggle!, using display: none)

hide! cljs

(hide! elem)

html cljs

(html elem)

insert-after! cljs

(insert-after! elem other)

Insert elem after other, other must have a parent

insert-before! cljs

(insert-before! elem other)

Insert elem before other, other must have a parent

listen! cljs

(listen! elem-sel & type-fs)

Adds f as a listener for events of type event-type on elem-sel, which must either be a DOM node, or a sequence whose first item is a DOM node.

In other words, the call to listen! can take two forms:

If elem-sel is a DOM node, i.e., you're doing something like:

(listen! elem :click click-handler)

then click-handler will be set as a listener for click events on the elem.

If elem-sel is a sequence:

(listen! [elem :.selector.for :.some.descendants] :click click-handler)

then click-handler will be set as a listener for click events on descendants of elem that match the selector

Also accepts any number of event-type and handler pairs for setting multiple listeners at once:

(listen! some-elem :click click-handler :hover hover-handler)

listen-once! cljs

(listen-once! elem-sel & type-fs)

Behaves like listen!, but removes the listener after the first event occurs.

live-listener cljs

(live-listener elem selector f)

fires f if event.target is found with selector

matches-pred cljs

(matches-pred selector)

(matches-pred base selector)

Returns a predicate on nodes that match selector at the time of this matches-pred call (may return outdated results if you fuck with the DOM)

parent cljs

(parent elem)

prepend! cljs

(prepend! parent child)

(prepend! parent child & more-children)

Prepend child to parent

px cljs

(px elem k)

remove! cljs

(remove! elem)

(remove! p elem)

Remove elem from parent, return parent

remove-attr! cljs

(remove-attr! elem k)

(remove-attr! elem k & ks)

Removes dom attributes on and returns elem. class and classes are special cases which clear out the class name on removal.

remove-class! cljs

(remove-class! elem c)

(remove-class! elem class & classes)

Remove c from elem class list

remove-style! cljs

(remove-style! elem & keywords)

Remove the style of elem using keywords:

(remove-style! elem :display :color)

replace! cljs

(replace! elem new)

Replace elem with new, return new

replace-contents! cljs

(replace-contents! p child)

Replace children of elem with child

scroll-into-view cljs

(scroll-into-view elem align-with-top?)

sel clj/s macro

(sel data)

(sel base data)

Same behavior as sel1, instead keeping the full array that by-class or by-tag expand to. Falls back to document.querySelectorAll instead of document.querySelector.

sel1 clj/s macro

(sel1 data)

(sel1 base data)

Select a single DOM node. Tries to expand to the native selector methods as defined by by-id, by-class, and by-tag, falling back to document.querySelector when the selector isn't a constant.

selector cljs

(selector data)

Returns a selector in string format. Accepts string, keyword, or collection.

set-attr! cljs

(set-attr! elem k)

(set-attr! elem k v)

(set-attr! elem k v & kvs)

Sets dom attributes on and returns elem. Attributes without values will be set to their name:

(set-attr! elem :disabled)

With values, the function takes variadic kv pairs:

(set-attr! elem :id "some-id"
                :name "some-name")

set-class! cljs

(set-class! elem c)

Set the css class of elem to elem

set-html! cljs

(set-html! elem html)

Set the innerHTML of elem to html

set-px! cljs

(set-px! elem & kvs)

set-style! cljs

(set-style! elem & kvs)

Set the style of elem using key-value pairs:

(set-style! elem :display "block" :color "red")

set-text! cljs

(set-text! elem text)

Set the textContent of elem to text, fall back to innerText

set-value! cljs

(set-value! elem value)

Set the value of elem to value

show! cljs

(show! elem)

special-listener-makers cljs

style cljs

(style elem)

(style elem k)

The computed style of elem, optionally specifying the key of a particular style to return

text cljs

(text elem)

toggle! cljs

(toggle! elem)

(toggle! elem show?)

Display or hide the given elem (using display: none). Takes an optional boolean show?

toggle-attr! cljs

(toggle-attr! elem k)

(toggle-attr! elem k add?)

Toggles a dom attribute k on elem, optionally specifying the boolean value with add?

toggle-class! cljs

(toggle-class! elem c)

(toggle-class! elem class add?)

(toggle-class! elem class) will add-class! if elem does not have class and remove-class! otherwise. (toggle-class! elem class add?) will add-class! if add? is truthy, otherwise it will remove-class!

unlisten! cljs

(unlisten! elem-sel & type-fs)

Removes event listener for the element defined in elem-sel, which is the same format as listen!.

The following forms are allowed, and will remove all handlers that match the parameters passed in:

(unlisten! [elem :.selector] :click event-listener)

(unlisten! [elem :.selector]
  :click event-listener
  :mouseover other-event-listener)

value cljs

(value elem)