converts children array to props

(children->props “hello” :mock/label) => {:text “hello”}

(children->props “hello” :mock/pane) => {:children “hello”}

checks if metatype is of :dom/component

(component? (dom-new :mock/label {})) => false

asserts that the props are valid (dom-assert {:a 1 :b 2} :a)

(dom-assert {:a 1 :b 2} :c) => (throws)

attaches a handler to a dom node

(-> (dom-attach (dom-create :mock/label) (fn dom event event)) :handler) => fn?

retrieves children of dom object

(dom-children (dom-create :mock/pane {} “hello”)) => {:key :children :children “hello”}

creates shallow copy of a node and its data

(def -a- (dom-create :mock/label)) (def -b- (dom-clone -a-))

(= -a- -b-) => false (dom-equal? -a- -b-) => true

compiles a tree structure into a dom

(-> (dom-compile :mock/pane “hello”) dom-format) => :- :mock/pane “hello”

(-> (dom-compile [:mock/pane :mock/label “hello” :mock/label “world”]) dom-format) => [:- :mock/pane :- :mock/label “hello” :- :mock/label “world”]

creates an dom

(dom-create :mock/pane {} “hello”) ;; :- :label “hello” => dom?

detaches a handler from a dom node

(-> (dom-attach (dom-create :mock/label) (fn dom event event)) (dom-detach) :handler) => nil

checks if two dom elements are equal

(dom-equal? (dom-create :mock/label {} “hello”) (dom-create :mock/label {} “hello”)) => true

formats dom for printing

(dom-format (dom-create :mock/label {} “hello”)) => :- :mock/label “hello”

returns itement associated with the dom

(-> (dom-new :mock/label {:a 1}) (impl/dom-render) (dom-item)) => mock/mock?

(-> (dom-new :mock/label) (dom-item)) => nil

returns whether dom has associated itement

(dom-item? (dom-new :mock/pane)) => false

(-> (dom-new :mock/pane) impl/dom-render dom-item?) => true

returns the associated metaclass

(dom-metaclass (dom-new :mock/label {})) => :mock/element

checks dom for ui type

(dom-metaprops (dom-new :mock/label {})) => (contains {:tag :mock/label :construct fn? :children {:key :text :single true} :metaclass :mock/element :metatype :dom/element})

returns the associated metatype

(dom-metatype (dom-new :mock/label {})) => :dom/element

creates a new dom type

(dom-new :mock/label {}) => dom?

checks if two dome nodes have the same props

(dom-props-equal? {:a 1 :b 2} {:a 1 :b 2}) => true

splits :on namespace keywords

(dom-split-props {:on/item :event/item :item “hello”}) => [{:on/item :event/item} {:item “hello”}]

checks if two dom nodes have the same tags

(dom-tags-equal? (dom-create :mock/label) (dom-create :mock/label)) => true

returns the top-most dom element

(def -a- (dom-create :mock/label)) (def -b- (dom-create :mock/pane {} [(dom-create :mock/pane {} -a-)]))

(dom-top -a-) => -b-

triggers an event, propogating up the dom hierarchy

(def -p- (promise))

(-> (dom-create :mock/label) (dom-attach (fn dom event(deliver -p- event) nil)) (dom-trigger {:a 1 :b 2}))

@-p- => {:a 1, :b 2}

checks if a vector can be a dom representation

(dom-vector? :fx/label "") => true

(dom-vector? ^:data :fx/label "") => false

checks if object is an dom

(dom? (dom-create :mock/label {} “hello”)) => true

checks if metatype is of :dom/element

(element? (dom-new :mock/label {})) => true

applies an action to props map

(props-apply {:a (dom-create :mock/label {:text “hello”}) :b (dom-create :mock/pane {} “world”)} (comp :props dom-item impl/dom-render)) => {:a {:text “hello”}, :b {:children “world”}}

checks if metatype is of :dom/value

(value? (dom-new :mock/insets {})) => true