looks like they break backwards compatibility hard https://github.com/google/closure-library/releases

I’m finding countless articles online about using Javascript libraries within Clojurescript.

How about the other way around?

When exporting a cljs project it attaches the library’s api to the global namespace (e.g. window). But, is there a way to export public functions as modules? For example, could I export a CLJS project and host it on NPM?

@kendall.buchanan it is possible if you really want to, see for example https://github.com/tonsky/datascript#using-from-vanilla-js

is there a way to check the existence of a key in an object using host interop syntax / in a way that is amenable to Closure compiler renaming? eg. some f for which (f? (.-x #js{:x nil}) would return true

(related to exists? but exists? does not do that)

@isak Thank you!

(defn error->stream
  [#js[exit err]]
  (.fromError
   stream
   (.assign js/Object err exit)))

@jayzawrotny you can, but without that #js. https://www.maria.cloud/gist/8ad61d0ce1d93a7d64551e57abf89b64?eval=true

Oh, brilliant! Thanks

#js is just for creating arrays / objects

I see, and in the arguments vector you’re not creating an array you’re just listing the symbols to pair with the values

precisely

How would you read a dynamic property of a js object?

(def name "msg")
(.-name #js {"msg" "hello"})

(gobj/get obj "dynamic_property")?

yep, https://github.com/google/closure-library/blob/master/closure/goog/object/object.js#L426

Ohhh, ok thanks. Gotta remember to refer to goog more.

I’ve been working on a little library that offers a more clojure-like approach to interop, https://github.com/appliedsciencestudio/js-interop

Would anyone have an idea of merging two anonymous functions into one?

;; Have this function
#(println "foo3")
;; Be merged into this function
#(do (println "foo1")
     (println "foo2"))

if your functions are thunks -- ie, arity 0 -- then its not hard

(defn keep-callin' [fs] (when-some [f (first fs)] (f) (recur rest fs)))

Ahh nice, now what if they have a higher arity, let's say 1

can you comp anonymous fns?

@mhuebert don't think so, fundamentally anything using the dot operator is subject to Closure renaming unless you hint ^js

if you look at the analyzer you'll see that externs inference needed to patch resolve-var to kick off externs tracking

and the dot form needed to change significantly to continue that tracking

cljs.user=> ((comp #(println "bye") #(println "hi")))
hi
bye
nil

@dnolen good info.. I think I meant to ask a slightly different question. Say you have performed (set! (.-x obj) nil). Is there a host-interop way to see that .-x has been set on obj? Thinking along the lines of how clojure lookups distinguish between presence-of-a-key and value-for-key, ie. why (get {:x nil} :x 10) returns nil

@mhuebert I just don't know what you're asking

what do you mean "host-interop"?

also I don't see how .-foo has much to do w/ get/keyword behavior really

Clojure doesn't mix the two at all

@mhuebert https://google.github.io/closure-library/api/goog.object.html (goog.object/containsKey obj "x") might be what you're looking for

that won't work

because x can be renamed

fair point

I think you can use proxies for that, but that's ECMAScript 2015 I think

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy

Like, if you want to detect if an object was set or get on

@mhuebert http://closuretools.blogspot.com

you might want to look at goog.reflect

I don't really fully understand what you're trying to achieve, so not sure if I'm sending you in the right direction

maybe goog.reflect + js-in which is macro for JavaScript in operator

By “host interop” I was just looking for closure-rename compatibility. I’ve been working on a js-interop lib that offers the same API as clojure core functions — has stuff like get, get-in, assoc!, assoc-in! and so forth. It mostly compiles down to goog.object calls. After writing the readme and giving a short talk yesterday I started looking deeper into alternatives and was wondering if it is even possible to express clojure’s lookup semantics (specifically this edge case of a key being present but nil) in a host interop / closure-renaming-friendly way. So there is no pressing need, I just didn’t know if I was missing something like (undefined? (.-x obj)). I had it in my head that exists? did this but was mistaken

I will have a look at goog.reflect

Thanks!

Looks to me like one could do this by using .canAccessProperty and .objectProperty in goog.reflect

So then I think I could get a call like (j/get-in o [‘x ‘y] not-found) to compile such that ‘x and ‘y (compile-time constants) are rename-able and the lookup behaviour matches that of regular get-in

using quoted symbols vs keywords might be a reasonable way to distinguish between the two behaviours

Ie (j/get o :x) vs (j/get o ‘x), static vs renameable

But that is beyond the point here.

How do you manage resources authorisation in SPA? Like page to log-in only for not logged users, when somebody is logged redirect to right place. When somebody want to open panel and is not logged, redirect to log-in and later back to this URL. Do you use any modules for that?

I would like to use something ready, but not sure which library

at that moment I use venantius/accountant for navigation and re-frame

But I miss pages access and redirections

I use a combination of venantius/accountant and clj-commons/secretary