what do you intend to do exactly? var based stuff is kinda tricky in CLJS since it doesn't really exist in runtime. it is all constructed from the analzyer data on the compiler side

so macros live in the clojure side, which is not all reflected in that analyzer data

if you are building a tool it might make sense to start with the compiler side analyzer data, rather than the slim layer on top provided by things like ns-publics which are all rather limited because of this separation

I have been trying something like (cljs.analyzer.api/ns-publics ns), but from what I can gather, you are suggesting I run this in CLJ? I want to pass the following things to Emacs: 1. list of all available namespaces (done through cider ns-list) 2. for each namespace, available symbols

this is a CLJ function? so I'm a little confused now 😛

where do you want it is the question? is the tool written in CLJS or CLJ? is the tool just running as part of the CLJS runtime? as in self-inspecting?

I want it to eventually support both, but currently cljs. I want it to be a docs-explorer for clj/s in emacs.

Yes

I am using nrepl for connecting to CLJS runtime I believe

thats confusing again. so emacs is the UI, aka client loading the info somehow and displaying it?

ok but this all happens over a REPL connection?

(defun ch-eval (str namespace)
  (assert (memq major-mode '(clojurescript-mode
                             clojurec-mode
                             clojure-mode)))
  (let* ((res (nrepl-sync-request:eval
               str
               (cider-current-connection)
               namespace))
         (status (nrepl-dict-get res "status"))
         (res (cond ((member "eval-error" status)
                     (error "Eval error"))
                    (t
                     res)))
         (val (nrepl-dict-get res "value"))
         ;; (out (nrepl-dict-get res "out"))
         )
    (read (string-trim val))))

Something like this:

(ch-eval (format
                "(->> (ns-publics '%s)
                (map (fn [[k v]]
                       (list (str k) (cond
                                 (:macro (meta @v)) 'macro
                                 (fn? @v) 'function
                                 :else 'variable)))))"
                namespace)
               ch-user-ns)

ok, yeah that should be ok. there are limits though. if you look at other emacs/cider related things they'll often look at the analyzer data directly

so cljs.env/*compiler* in particular

Ah, okay. So I shouldn't look in cljs.analyzer.api.

Which namespaces should I look at?

well, it is tricky

you need to realize that CLJS does not have reified vars at runtime, so everything var related is "fake"

yeah...

I'd suggesting looking at the cljs.analyzer.api ns directly

Right. I tried something like (cljs.analyzer.api/ns-publics 'cljs.core) , and getting errors.

Execution error (Error) at (<cljs repl>:1).
No protocol method IDeref.-deref defined for type null: 
:repl/exception!

it is basically only meant for either usage from CLJ directly, or self-hosted CLJS

yes, exactly because of what I just said. it'll not work in the regular non-self-hosted CLJS build

hmm. tricky.

you can use cljs.core/ns-publics instead, but that then has all the limitations macros have. i.e. no dynamic arguments

i guess one workaround is (at least for personal use) always connect full-stack, and just query clj

but it should be fine for the snippet you linked above

i have been doing that, and there are two issues: 1. some definitions don't show up (I can live with this as these are fairly basic like defn) 2. it seems... unreliable? the program sometimes breaks. i can't trace the issue rn

shouldn't be unreliable, but yes it may be incomplete with regards to macros

Yeah, it may be something I am doing in the wrapper/reading that is causing issues. I just need to get down and look at it.

Oh, I think I was restarting so often for debugging that I forgot to launch/refresh the CLJS runtime. That was causing issues.

I dont think one exists, but you can make a regex spec like so

(def dot-property-re #"^\.-[a-zA-Z_$][0-9a-zA-Z_$]*$")

(map (partial re-matches valid-re) 
     [".-foo" ".-42" ".-snake_case"])

;; => (".-foo" nil ".-snake_case")

unfortunately this will fail against unicode property names… in javascript you can still use

let o = {定数: 2.71828}
const e = o.定数;

Thanks! Yes, ideally I would get something very generic, it's for tooling so I need to keep an eye for unforeseen cases

well, i just took a look at CLJS compiler and I do not see any validation done

(defn emit-dot
  [{:keys [target field method args env]}]
  (emit-wrap env
    (if field
      (emits target "." (munge field #{}))
      (emits target "." (munge method #{}) "("
        (comma-sep args)
        ")"))))

(defmethod emit* :host-field [ast] (emit-dot ast))
(defmethod emit* :host-call [ast] (emit-dot ast))

so if you write (.-42 obj) the compiler will try to emit obj.42 and that results in an JS error

so yeah… the best thing you can do IMO is extend the regex I provided to supporting unicode characters

but the regex I wrote should at least mark everything cljs.core emits as valid… problems come when you run into the 0.1% of code actually using non-ASCII characters for object fields

> well, i just took a look at CLJS compiler and I do not see any validation done nice dive, kudos! maybe for the time being I will banlist instead of allowlist. For example I have the practical problem of would-be symbols starting with a digit. It's easy to hardcode a few rules like that. If you're curious about the context, it's: https://github.com/clojure-emacs/clj-suitable/issues/39

Huh, interesting. A few months ago I was playing around with some JavaScript code to compute all fields and methods of an object by looking at its prototype chain. The goal was to obtain autocomplete of javascript code from npm modules, but I never go that far

we also have an issue for npm modules. maybe we don't need much special stuff for it to work, I'd just have to dig into the code

I came up with something like this to compute fields

const fields = (obj) => {
  let result = new Set();
  let current = obj;

  do {
    Object.getOwnPropertyNames(current).map(key => result.add(key));
  } while ((current = Object.getPrototypeOf(current)));

  return [...result.keys()].filter(key => typeof obj[key] !== "function");
}

e.g. given

let example = {
    foo: 1,
    bar: () => 1,
    baz: 1
};

console.log(fields(example));

[ "foo", "baz", "__proto__" ]

the hard part is determining what object to inspect when the user simply supplies an alias… e.g. if they have

(ns example
  (:require ["react" :as react]))

since shadow-cljs already has a way to convert all of these kinds of exports into an object in the global namespace (e.g. module$node_modules$react$dist$index… or something like that), then I think it would be easy to support autocomplete with just 2 functions: • computing fields and methods like I described above • using shadow-cljs api to resolve a required node module to the global object in one’s JS environment

Thanks! Will study this carefully and link it to in our github issue

That should work. A better way to write that would be to use #js {...} instead of (clj->js {...}) - works for static keys, does the processing at compile time and is shallow, so overall a better fit.

For some reason, it doesn't work with #js:

(#js {
                            show (fn []
                                    (js/console.log "show ui")
                                    (render-app)
                                    (js/logseq.showMainUI))
                            hide (fn []
                                    (js/console.log "hide ui")
                                    (js/logseq.hideMainUI))
                                    })

I get an error

Drop the parens around #js.

And add : in front of the fields, #js {:show ..., :hide ...}.

Awesome it works! thanks a lot