I'm integrating with an existing app built with requirejs and knockoutjs. All is peachy until compiling with advanced optimizations. How can I specify the "types" of objects requirejs passes to my functions, e.g. in this bit of code:

(defn subscribe-login-state [subscription-fn]
    (.require js/window
            (array "some/module/customer-data")
            (fn [customer-data]
              (let [customer (.get customer-data "customer")]
                (.subscribe customer #(subscription-fn (boolean (.-fullname %)))))))

Is it possible to type hint customer-data and customer, and then add those to an externs file?

@vinai https://clojurescript.org/guides/externs

Good Morning everyone… So, put simply, how do I “de-render” a Reagent component so that I can render another one..?

@maleghast i've had luck by providing a metadata key that deref's an atom for the component. When the atom (and therefore the key) changes reagent will de-render the component and render a new one associated with the new key.

Not sure if this is the best solution though. Would be interested to see if anyone has a better one.

Thanks @brown.joshua49 - I will investigate that as well…

🙂

Your welcome, i spent quite awhile the other day researching that 🙂. It seriously tripped me up that updating the react component is not the same as de-rendering and rendering a new one.

@maleghast what do you mean by "de-rendering"?

@pesterhazy - I mean the ClojureScript / Reagent equivalent of pulling some markup out of the DOM and inserting some new markup in its place.

i.e. “render” in React/Reagent land is “make markup, push into DOM”, so “de-render” would be “take markup out of the DOM”. Clearly I would “render” to put the new stuff in place - I can see that.

This seems like a basic React question. If you don't have React experience, a good React tutorial would be a good place to start.

In a nutshell, you don't take markup out of the DOM. Instead, you just don't emit the corresponding React elements the next time the component renders, and you do something to cause the component to rerender.

@pesterhazy - Yes, that has broadly been established ^^ and I have been looking into such things between conference calls. I was casting around, hoping that someone would say “oh that’s easy you just…” and I could crack on, but no matter, and thanks anyway 🙂

In React that would be changing this.state; in Reagent we use ratoms for that.

(def hidden? (r/atom true))

(defn my-comp []
   (if @hidden? [:div] [:div "Here I am. Look at me!"]))

would be a simple way to do it

That seems pretty elegant / simple - thanks for that 🙂

To cause the state change, you just need to (reset! hidden? false) in an event handler

*nods*

Next step would be to use a global state atom for that.

total newb question. ive just been learning Clojure for a few weeks, im mainly a JS dev in my day to day. does anyone have a good video/article about getting started with Clojurescript and front end frameworks, like React/Angular ?

you really shouldn’t use react or angular directly with ClojureScript, that doesn’t make sense really. You should use a ClojureScript library (and most of those wrap react, so not all of your react knowledge is lost) built for that thing

I personally love reagent+re-frame combination but your milage may vary

it would be easier to first use just reagent and then add re-frame on top of that later. Although you’ll most likely end up rewriting your frontend that way but everything you learn while using just reagent still is very much valid when using re-frame

this looks relatively good basic tutorial into reagent http://timothypratley.blogspot.fi/2017/01/reagent-deep-dive-part-1.html

hi, is the &env hack still the official way to detect the target environment inside a macro ?

@leonoel It was never official, but it should still work AFAIK.

@pesterhazy - Just wanted to update you… The behaviour I was looking for is perfectly executed by rendering a new component in the same DOM location. Thanks!

thank you @mfikes !

Look! https://www.reddit.com/r/Clojure/comments/7a3ekm/bashlike_shell_based_on_lumo/

neat!

@maleghast glad you got it to work!

🙂

Hi! I've got a test that's failing under advanced compilation settings. Other tests are running fine. I'd like to exclude only this test when running under advanced compilation. I'm using lein cljsbuild. Any pointers as to how I might accomplish this?

@grzm A bit crude, but maybe you could put the test in a separate file, and then not include that file it in the build configuration that uses advanced compilation?

@grav yeah, that's an idea I had as well. thanks for confirming it may be worth pursuing.

No problem. Still, it seems a bit like a hack to me, and may result in lots of duplication in project.clj

There’s some documentation regarding test support here, although I can’t seem to find anything that fits your problem well: https://github.com/emezeske/lein-cljsbuild/blob/1.1.7/doc/TESTING.md

that's why I thought I'd ask trying it 🙂 Taking a step back, do you think my original question is a reasonable concern that may not have been addressed yet? I find that sometimes when I'm too close to the problem I'm missing the bigger picture.

Yup, know that feeling. My only experience with :advanced is that it poses some challenges, and that it’s not always relevant. So I have to admit I only use :whitespace.

@grzm I would figure out why that test is failing first

this can be usually be done with :pseudo-names true, :pretty-print true

other than that, use :main

In any case, it’s interesting to have the failing test as documentation for when you’re ready to investigate further.

@dnolen I'm trying to get the file and line number from a stacktrace: I'm hacking on the tooling in test.check

From what I've seen so far, under advanced compilation I'm not able to get back to the original source file

since I don’t have any details I can’t tell you anything more

but that’s not generally true - source mapping works through advanced compilation

if you’re using the testing documentation helper macros that could also help

cljs.test/testing etc.

thanks. I'll take a look. This is the test I'm working on right now: https://github.com/clojure/test.check/blob/TCHECK-34-js-file-and-line-2/src/test/clojure/clojure/test/check/clojure_test_test.cljc#L143-L157

The code that's handling the check is here:

I'm more familiar working in the clj space than the cljs space.

https://github.com/clojure/test.check/blob/TCHECK-34-js-file-and-line-2/src/main/clojure/clojure/test/check/clojure_test.cljc#L19-L28

+ the required assertions.* files. The clj stuff works fine, as does nodejs with :none

Though the short answer appears that I should be able to get it working. So, back into the code.

How would you write this: 1. (JSON/stringify #js {:foo "a-foo" :bar "a-bar"}), or 2. (.stringify js/JSON #js {:foo "a-foo" :bar "a-bar"}) The latter does not yeild a warning, so it might be the correct one, but I’m trying to understand how does 1. even work? Or is there better way to convert arbitrary structure to json, that I’m missing? Thank you.

the first one errors because JSON needs to be namespaced via js/ unless you created it as a new binding yourself

in my cljs repl it doesn't work - I can't tell you why it works in yours

Interestingly, JSON/stringify works here http://clojurescript.net/ but not here http://clojurescript.io/

I’m using figwheel in react-native, maybe that’s a factor here? In any case you suggest I go with version 2.?

that's the one that actually matches the cljs docs yes

@pawel.kapala (js/JSON.stringify #js {:foo "a-foo" :bar "a-bar"})

that's also acceptable yes

Hello! Quick beginner question: is there a nice devtool for any of Om Next / Reagent / Rum / else? Om Next has some notion of state management, the others do not, but I am wondering if there is a nice setup with any of these to get state management (ala redux) with a tool to do time-travel debugging, etc

@hmaurer: for reagent/re-frame, I've very much liked: https://github.com/Day8/re-frame-trace Was pretty easy to set up. Also there are some great resources here (including stuff on time-travel): https://github.com/Day8/re-frame/blob/master/docs/External-Resources.md

@pawel.kapala I now prefer the form (.stringify js/JSON #js {:foo "a-foo" :bar "a-bar"})). It is definitely correct, and you will get a helpful compiler warning if JSON happens to be a local as in

cljs.user=> (let [JSON 1] (.stringify js/JSON #js {:foo "a-foo" :bar "a-bar"}))
WARNING: js/JSON is shadowed by a local at line 1 <cljs repl>

the js/foo.bar syntax always feels uncanny valley to me - not quite clojure and not quite other-language, even though I know it works

@mfikes thanks! Still I wonder how is it technically possible to execute 1. Is there JSON namespace out there? Planck produces correct result but with a warning it wouldn’t find JSON ns..

cljs.user=> (JSON/stringify #js {:foo "a-foo" :bar "a-bar"})
             ^
WARNING: No such namespace: JSON, could not locate JSON.cljs, JSON.cljc, or Closure namespace "" at line 1 
WARNING: Use of undeclared Var JSON/stringify at line 1 
"{\"foo\":\"a-foo\",\"bar\":\"a-bar\"}"

It just happens to generate JavaScript that works. Try planck -v and you'll see this. But it is just an accident related to the way namespaces and contained Vars are implemented as nested JavaScript objects.

oh wow - now that I double check, my repl was doing the same thing - it just printed the warnings after the correct output so I missed it

@mfikes Now I see it, so 1. is definitely wrong way of writing it. It is just a coincidence it actually works.. Thank you for clarifying this!

Any garden users in the house? I have a question about using the garden.color records inside of my defstyles code…

I’m wondering if it’s possible to specify to format of the CSSColor record as either hsla hex without calling the as-hex or as-hsl functions directly… perhaps there’s also a way to implement the toString protocol on the type… I’m new to Clojure so I’m unsure, but I imagine that there is something that’s converting the record into a string before writing to the .css file. Any direction would be appreciated.

Are there are serious performance implications I should be aware of before implementing a toString protocol on a record or a type? I’m looking for whichever protocol is used when (str ...) is called