(behavior ::on-close-destroy          :triggers #{:close}          :reaction (fn [this]                      (object/raise this :destroy)))

(object/object* ::user.hello                :tags [:user.hello]                :behaviors [::on-close-destroy]                :init (fn [this]                        (hello-panel this)))

(object/raise app :closing)

(defn raise*  ([obj reactions args] (raise* obj reactions args nil))  ([obj reactions args trigger]   (doseq [r reactions           :let [func (:reaction (->behavior r))                 args (if (coll? r)                        (concat (rest r) args)                        args)                 meta (if (coll? r)                        (meta r)                        {})]           :when func]     (try     (with-time       (binding [*behavior-meta* meta]         (apply func obj args))       (when-not (= trigger :object.behavior.time)         (raise obj :object.behavior.time r time trigger)))       (catch js/Error e         (safe-report-error (str "Invalid behavior: " (-> (->behavior r) :name)))         (safe-report-error e)         )       (catch js/global.Error e         (safe-report-error (str "Invalid behavior: " (-> (->behavior r) :name)))         (safe-report-error e)         )))))(defn raise [obj k & args]  (let [reactions (-> @obj :listeners k)]    (raise* obj reactions args k)))

(defn handle-redef [odef]  (let [id (::type odef)]    (doseq [o (instances-by-type id)            :let [o (deref o)                  args (:args o)                  old (:content o)                  behs (set (:behaviors o))                  inst (@instances (->id o))                  neue (when (:init odef)                         (apply (:init odef) inst args))                  neue (if (vector? neue)                         (crate/html neue)                         neue)]]      (merge! inst {:tags (set/union (:tags o) (:tags odef))                                      :behaviors (set/union behs (set (:behaviors odef)))                                      :content neue})      (merge! inst (update-listeners inst))      (when (and old neue)        (replace-with old neue))      (raise inst :redef))    id))(defn object* [name & r]  (-> (apply make-object* name r)      (store-object*)      (handle-redef)))

(defn update-listeners  ([obj] (update-listeners obj nil))  ([obj instants]   (let [cur @obj         behs (set (concat (:behaviors cur) (tags->behaviors (:tags cur))))         trigs (->triggers behs)         ;;We need to load new JS files here because they may define the behaviors that we‘re meant to         ;;capture. If we have a load, then load and recalculate the triggers to pick up those newly         ;;defined behaviors         trigs (if (:object.instant-load trigs)                 (do                   (raise* obj (:object.instant-load trigs) nil :object.instant-load)                   (->triggers behs))                 trigs)         trigs (if instants                 trigs                 (dissoc trigs :object.instant :object.instant-load))]     ;;deref again in case :object.instant-load made any updates     (assoc @obj :listeners trigs))))

(defn ->triggers [behs]  (let [result (atom (transient {}))]    (doseq [beh behs            t (:triggers (->behavior beh))]      (swap! result assoc! t (conj (or (get @result t) ‘()) beh)))    (persistent! @result)))