is there a good configuration handling post for cljs?

anybody use https://github.com/clj-commons/secretary for client-side routing?

how can I navigate to a certain route from within a re-frame event?

trying to "cheat" by doing (defn goto [path] (set! (.-href js/location) path)) but doesn't work, secretary seems unable to perform the parameter destructuring

the docs state that by using named routes you can run them as functions, f.ex. (my-route {:param "foo"})should execute the corresponding defroute but that also seems to achieve nothing

the error message seen is Uncaught Error: No protocol method IMapEntry.-key defined for type cljs.core/LazySeq: (:id "1")

seems to originate from secretary.core.locate-route

I recently added routes, maybe as example it might help. I liked it basiccaly you only have to match parts of the url with parts of the db, and then it works. https://github.com/openweb-nl/kafka-graphql-examples/blob/master/frontend/src/cljs/nl/openweb/bank/routes.cljs

point is everything used to work, until I updated all the project dependencies.

routing via clicking links with hrefstill does work fine, but not when trying to call the routes dynamically or alter js/location

how does that work with bidi?

With the google closure ui autocomplete component (demo: https://google.github.io/closure-library/source/closure/goog/demos/autocomplete-basic.html), does anyone know how I attach a listener to a value from the dropdown being selected?

I've been trying things like

(.listen my-ac-component
   goog.ui.ac.AutoComplete.EventType/SELECT
   (fn [e] (js/console.log e)))

I believe you use goog.events.listen

https://developers.google.com/closure/library/docs/events_tutorial

Ok figured it out, I guess you need to listen to the renderer and not the autocomplete object:

(defn ac []
  (let [el      (input)
        matcher #js{}
        input-handler (goog.ui.ac/InputHandler. nil nil false)
        _             (set! (.-requestMatchingRows matcher)
                            (fn [q max-matches cb]
                              (cb q (get-matches q))))
        renderer      (goog.ui.ac/Renderer.)
        ac            (ac/AutoComplete. matcher
                                        renderer
                                        input-handler)]
    (.listen renderer
             goog.ui.ac.AutoComplete.EventType/SELECT
             (fn [e] (js/console.log e)))

    (.attachAutoComplete input-handler ac )
    (.attachInputs input-handler el )

    el))

I’ve been trying to use unicode property escapes in regex and I’m just getting errors… Any idea how to do the equivalent of this: var regex = new XRegExp("\\p{L}")

What do I need to do make a sub update when a field that its dependent on the db updates?

(rf/reg-sub
 ::refs
 (fn [db]
   (let [refs (-> db :card-meta :refs)]
     (println "Active: " (:active refs))
     ((:active refs) refs))))

Where are you using (deref'ing) the sub?

here

(defn ref-list []
  (let [refs (rf/subscribe [::subs/refs])]
    [:ul.ref-list 
     (doall (for [ref @refs]
              ^{:key ref}
              [:li [:h4 (:id ref)]]))]))

Where is located the ref-list component call?

Here

(defn ref-view []
  [:div.header {:style {:margin-top "0.50em"}}
   [ref-list]])

(defn main-panel []    
  (add-shortcuts!)
  (fn []
    [:div.container  
     [ref-list]]))

Try:

(defn ref-list []
  (let [refs (rf/subscribe [::subs/refs])]
    (fn []
      [:ul.ref-list 
       (doall (for [ref @refs]
                ^{:key ref}
                [:li [:h4 (:id ref)]]))])))

((:active refs) refs) what does this do?

Can you add printline in ref-list before doall and deref the refs there? Just curious to see if you get the updated value out of the loop

Tried

(defn ref-list []
  (let [refs (rf/subscribe [::subs/refs])]
    (println "UPDATE!")
    [:ul.ref-list 
     (doall (for [ref @refs]
              ^{:key ref}
              [:li [:h4 (:id ref)]]))]))

If both :to and :from are [] then it won't update the component

If you had N different commands/shortcuts that can be invoked from your re-frame app would you register N different event-handlers that takes :CMD-A-INVOKED... or a single handler that takes CMD-INVOKED {:id .. :args} ? Second one offers more control but feels like re-inventing reframe?