For Clj we use buddy, which has served us pretty well

I like firebase.

Thanks.

Please note that I have been mostly doing Clojure development, so I’m not too familiar with the exact differences between Clojure and ClojureScript.

We currently use oops, gets the job done well (also it’s a nice api)

Oh and actually now that I think of it: do I also need this when using shadow-cljs?

my advice is to never use cljs-oops

when working with data (eg. json) use goog.object/get

when working with code use regular interop and let extern inference to its thing, which just means you sometimes need to provide ^js hints on things that are JS objects

agree with that... bit more info here https://widdindustries.com/clojurescript-jsinterop/

Thanks for your insights! I’m removing the cljs-oops dependency :)

Is there a way to catch possible instances of items which might need to get type hinted? We’re using oops because we had too many cases of externs not being caught

there is *warn-on-infer* described here: https://clojurescript.org/guides/externs which will print WARNING: Cannot infer target type in expression ..

I think there is some way to make specific warnings fail the build... or maybe that's in discussion still I can't remember

in shadow-cljs it is default to warn for all of your sources. the default otherwise is only to warn if enabled, so if you are not using shadow-cljs and have not enabled warnings manually then you get no warnings at all

inference still happens but will likely be incomplete due to those missing js hints

IIRC the least invasive solution is to have a fully transparent div on top of it with that tooltip.

Okay

Thanks @U2FRKM4TW I have used bootstrap data-toggle ="tooltip"

I want to be able to use something like (tabler-icon "IconPlaneDeparture")

you’ll need to require all of the icons you want to use no matter what

macros used outside of ns can’t add requires in production

but you could add a map of strings->components and then use tabler-icon like [tabler-icon “IconPlaneDeparture”]

What if i do something like this:

(ns app.components.icons.icons
  (:require [reagent.core :as r]
            ["@tabler/icons" :as tabler-icons]))

(defn tabler-icon [name]
  (r/as-element [:> tabler-icons/name {:color "#6a35ff"
                                       :stroke 1.25
                                       :size 24}]))

The only problem is that the parameter name can't be used. I wonder if I could do it with a macro?

you can’t

Found this from stackoverflow https://stackoverflow.com/questions/2966014/how-do-i-create-a-macro-to-define-two-functions-in-clojure

; given a function name, its args and body, create 2 versions:
; ie (double-it foo [] ) should create 2 functions: foo and foo*
(defmacro double-it                
  [fname args & body]         
  `(do (defn ~fname ~args ~@body)
       (defn ~(symbol (str fname "*")) ~args ~@body)))

(double-it afunc [str] (println str))

(afunc* "asd")
(afunc "asd")

Here they create a function name from a string using symbol

@U4YGF4NGM Wherein lies the limitation?

the stackoverflow you posted is different than what I thought you were talking about

let me be clear what I'm saying you can't do: you can't have a function or a macro which allows other namespaces to dynamically refer or require things for you.

in ClojureScript, at least. Clojure is different

If i allow myself to require all of the icons, would it then be possible?

there's a lot you could do but I'm going to cut to: I think your best bet is to require the icons and use a macro to generate the various functions you want to use

What functions do you mean?

here's an example of what I mean: https://github.com/lilactown/helix/blob/master/src/helix/dom.cljc

this generates a bunch of macros (but could be functions) like input, div, etc. to cut down all the boilerplate

then you can refer helix.dom/div helix.dom/input etc.

you can create a macro to generate the icon-plane-departure fn in your original post and any other icons you need

the limitation you're working around is that a namespace needs to refer to anything that's going to be used in it, so that it's statically analyzable, so that the clojurescript and google closure compiler emits the correct code

this is different than Clojure, which includes the compiler with your program. ClojureScript does not, so it has to do everything ahead of time, which means we're restricted more on how dynamic we can be

how doesn't it work?

name resolves to a symbol. A symbol that's not bound. It should be passed quoted or turned into a string beforehand.