bind-view.clj

(defn bind-view-watch-fn [id render-func]
  (let [ky (str "EVB:" nid)]
    (fn [ctx ref oval nval]
      (let [node (.getElementById js/document id)]
        (if node
          (render-func node nval)
          (remove-watch ref ky))))))



(defn bind-view [atm render-func]
  (fn [node]
    (let [id (from node (get-attr :id))
          nid (if (empty? id) (gen-sym "BIND_") id)]
      (when-not (= id nid) (at node (set-attr :id nid)))
      (render-func node @atm)
      (add-watch atm ky (bind-view-watch-fn nid render-func)))))


(defn get-unify-prop [obj field]
  (cond
   (and (map? obj) (seq? field)) (get-in obj field val)
   (map? obj) (obj field)
   (and obj (keyword? field )) (aget obj (name field))
   (and obj (string? field)) (aget obj field)
   (and obj (seq? field)) (if (empty? (rest field))
                            (aget obj (first field))
                            (recur (aget obj (first field)) (rest field)))
   :else nil))


(defn set-unify-prop [obj field val]
  (cond
   (and (map? obj) (seq? field)) (assoc-in obj field val)
   (map? obj) (assoc obj field val)
   (and obj (keyword? field )) (do (aset obj (name field) val) obj)
   (and obj (string? field)) (do (aset obj field val) obj)
   (and obj (seq? field)) (do
                            (if (empty? (rest field))
                                (set-unify-prop obj (first field) val)
                                (set-unify-prop (aget obj (first field)) (rest field) val))
                            obj)
   :else obj))



(defn key-or-props [obj]
  (if (map? obj)
    (keys obj)
    (gobj/getKeys obj)))


(defn default-bindings-opts {:type :one-way
                             :event :onblur
                             :field nil})



(defn bind-input [atm opt-map]
  (let [opts (merge default-binding-opts opt-map)]
    (fn [node]
      (at node (bind-view atm (fn [node val]
                                (let [nval (if (:field opts)
                                             (get-unify-prop val (:field opts))
                                             val)]
                                  (when-not  (= (.-value node) nval)
                                    (aset node "value" nval))))))
      (if (= (:type opts) :two-way)
        (at node
            (listen (:even opts)
                    (fn [e]
                      (swap! atm #(set-unify-prop %
                                                  (:field opts)
                                                  (aget e "currentTarget" "value"))))))))))


(defn save-form-to-atm [atm form field-map]
  (let [form-vals (ef/from form (ef/read-form))]
    (swap! atm (fn [cur]
                 (reduce #(let [ky (if field-map (%2 field-map) %2)
                                nval (ky form)]
                            (if nval
                              (set-unify-prop %1 key nval)
                              %1))
                         (or (keys field-map)(key-or-props cur)))))))



(defn bind-form
  ([atm] (bind-form atm nil))
  ([atm field-map]
     (fn [node]
       (at node (listen :submit
                        (save-form-to-atm atm node field-map)))
       (map #(let [ky (if field-map (%1 field-map) %1)]
               ) (keys cur)))))

Forked and rewritten https://gist.github.com/runexec/6879307