Nothing built-in, but It's a one-liner given the constructor js/Promise.

You're right, I was out of my game this morning 😅

The most straightforward way to do it would be to remove the focus from the element by calling .blur on its DOM node.

(-> e (.-target) (.blur)) instaed of the println

THANKS! 🙏

BTW can be slightly shorter with (.. e -target blur). :)

I don't like .. but sure that works too 🙂

Just a personal preference? And maybe the fact that IIRC Cursive still doesn't treat it right.

nah just too limited. can only do interop forms, too many times I started with .. but then wanted to call a clojure function

so now just using -> and adding a couple extra dots where needed

Ah, true, makes sense.

also works better with as-> cond-> etc

I was googeling .. a couple of hours ago. Syntax in Clojure/-Script can be so much fun :)

@U02AMR8032L Best results I can find on such things comes from searching for "clojurescript interop"

That's just how it works in browsers. But you can also listen to the contextmenu event, I believe.

I believe the AudioWorkletProcessor is only available in an actual audio worklet. the one instantiated in the other file. So you can only port the other file to CLJS, but the actual worklets is probably best left as JS.

Thanks @thheller. In fact I have left both files as JS. I am including both JS files using (something like) ...

(hiccup.page.html5.include-js ["webaudio.js" "processor.js"])

yeah you don't load the processor directly via the html

at least I'd assume that the webaudio.js is triggering the load, not the html

Thanks @thheller! That helped narrow it down. I needed to specify the directory name "js" within the "public" folder when loading processor.js from webaudio.js, i.e., "js/processor.js". Wasn't necessary when running with basic html and javascript using python's http.server..... now I know!

Hi 👋 This seems to work: .clj file

(ns ellisperati.macros)
(defmacro foo [& body] (str "bar" body))
(intern 'cljs.core (with-meta 'foo (meta #'foo)) #'foo)

(ns ellisperati.macros
  (:require-macros [ellisperati.macros]))
(prn "FOO" (foo baz))

Hey, I’m not sure if this is only works with figwheel. but I couldn’t get it to work with shadow-cljs. this is what my .cljc file looks like

(ns my.macros)

(defmacro foo [& body] (str "bar" body))
#?(:clj (intern 'clojure.core (with-meta 'foo (meta #'foo)) #'foo)
   :cljs (intern 'cljs.core (with-meta 'foo (meta #'foo)) #'foo))

#?(:clj (do (intern 'clojure.core (with-meta 'foo (meta #'foo)) #'foo)
            (intern 'cljs.core (with-meta 'foo (meta #'foo)) #'foo)))

Hi, are you sure you have this code in your my/macros.cljc file:

(ns my.macros
  #?(:cljs (:require-macros [my.macros])))

#?(:clj (do (defmacro foo [& body] (str "bar" body))
            (intern 'clojure.core (with-meta 'foo (meta #'foo)) #'foo)
            (intern 'cljs.core (with-meta 'foo (meta #'foo)) #'foo)))

Also might be nice to check what ClojureScript version are you using? I'm on ClojureScript 1.11.60 and Clojure 1.11.1

Important thing to note about the differences in the code you pasted: The intern needs to be done in #?(:clj, not #?(:cljs because the macros (even cljs.core macros) live in CLJ land

@U02CVMEFEUF does that make sense? FWIW it works for me as you describe (can use foo anywhere without referring it explicitly so long as macros has been referred anywhere prior -- this is required so that foo is interned). If you are still stuck please post a repo or some snippets?

you’re right I missed this part

(ns my.macros
  #?(:cljs (:require-macros [my.macros])))

Only ClojureScript can :require-macros (it's invalid in Clojure)

What happens is the compiler loads CLJC files compiling to ClojureScript, but the :require-macros causes it to then load the exact same file in Clojure (because that's where the macros live), when it loads in Clojure it can't do the ClojureScript stuff, when it loads in ClojureScript it can't do the Clojure stuff

I meant I’m requiring the macros defined in the same namespace, which is what I find confusing. I came across a similar pattern in cljs.core

That's what makes macros in CLJC confusing 🙂

> What happens is the compiler loads CLJC files compiling to ClojureScript, but the :require-macros causes it to then load the exact same file in Clojure (because that’s where the macros live), when it loads in Clojure it can’t do the ClojureScript stuff, when it loads in ClojureScript it can’t do the Clojure stuff oh I see

🙂

I will test it out and get back to you

👌

hey @U06S1EJPL it worked, the only hitch is that I need to require-macros in one namespace, before It’s available everywhere. but I guess I can live with that. thanks. last question, the reason I could intern these macros was only because the macros are compiled in clojure, but I wouldn’t be able to intern functions :thinking_face:

Right. I'm not sure how to add a function such that you can use it without requiring or referring it sorry 🤷

@U06S1EJPL sorry to bother you again but If macros get compiled in clojure. then how come macroexpand and its variants don’t work when I call it inside a macro? I’ve tried using cljs.analyzer/macroexpand-1 like this

(ns my.core
  (:refer-clojure :exclude [#?(:cljs macroexpand)])
  (:require
    [cljs.analyzer :as ana]
    [clojure.walk :refer [prewalk]]))


#?(:clj (defn macroexpand*
          [env form]
          (if (contains? env :js-globals)
            (loop [form form
                   form* (ana/macroexpand-1 env form)]
              (if-not (identical? form form*)
                (recur form* (ana/macroexpand-1 env form*))
                form*))
            ;; clj
            (macroexpand form))))


#?(:clj (defn macroexpand-all
          [env form]
          (prewalk (fn [x]
                     (if (seq? x)
                       (macroexpand* env x)
                       x))
                   form)))


#?(:clj (defmacro my-macro
          [form]
          (macroexpand-all form)))

Hi @U02CVMEFEUF -- Looking at the code you linked, it seems suspicious to me that defn* and other macros are not wrapped in #?(:clj) The issue is that when you load a CLJC file, it sees in the ns declaration to refer-macros so it loads the file in "Clojure", but subsequently it continues loading the file in "ClojureScript"... and thus I expect that your macros are getting replaced by ClojureScript functions! When ClojureScript compiles defmacro it actually just creates a function. You don't want that. I expect that if you wrap all your defmacro forms in #?(:clj) it might solve your issue, however I can't promise anything as it's just based on your description and the code. If that doesn't work could you please provide more instructions on how to reproduce the problem you are facing? Specifically the part about "When I package it and load it via shadow-cljs.edn in another project, the macroexpansion doesn’t take place" -- assuming the above is still a problem, could you link to the "other project" and provide instructions on how to build it, and what the expected output is?

Any luck getting it to work?

Hey, sorry I completely missed this. Yes I managed to get it to work. I think it was some issue with leiningen/shadow-cljs not picking up the latest version of the jar. It got resolved on its own. Thanks for your help 🙂

Oh, great! 🙂