Clojure Q&A - Recent questions tagged clojurescript

Missing protocol error will hang on infinite `(range)` input in ClojureScript but not Clojure

Fri, 03 Apr 2026 11:16:47 +0000

functions like transient, assoc, etc will throw helpful missing-protocol error when receiving invalid input but it will hang if it receives infinite (range).
this is related to issue below
https://ask.clojure.org/index.php/14578/even-range-hangs?show=14578#q14578

however, missing-protocol only hang in clojurescript but not clojure so I am wondering if this difference is intended.

example calls that should throws
- (transient (range))
- (assoc (range) :a 1)

TypedArrays don't implement ICounted in cljs

Thu, 05 Feb 2026 12:37:54 +0000

I just discovered that JS TypedArrays (Uint8Array et al) do not implement ICounted out of the box, even though it's trivial to make them do so. As a result count doesn't work on them; this is in contrast to Clojure where count works on arrays of primitives. Can/should this be added, or is the current behaviour intended?

(count (js/Uint8Array. [1 2 3]))
;; Execution error (Error) at (<cljs repl>:1).
;; No protocol method ICounted.-count defined for type object: 1,2,3
;=> :repl/exception!

(extend-protocol ICounted
 js/Uint8Array 
 (-count [this] (alength this)))
;=> #object [Function]

(count (js/Uint8Array. [1 2 3]))
;=> 3

bit-count in cljs but not clj

Fri, 30 Jan 2026 09:21:40 +0000

The bit-count function ships as part of CLJS but not CLJ, which means I end up using a reader conditional to use Long/bitCount on the JVM side when I write cljc files. It would be nice if I could just use bit-count.

(I chose "compiler" for category because there's no option for "standard library")

Literals for Unicode code points (and perhaps also sequences thereof)

Mon, 12 Jan 2026 20:02:41 +0000

Context
For historical reasons the JVM type system's support for Unicode code points is poor, and while this is usually invisible to the developer it becomes a hassle when String literals containing non-Latin1 code points are used in code. It also becomes particularly problematic when cross-platform (cljc) code is attempting to do this, since other platforms may not share this historical oddity so solutions that "work" in ClojureJVM may break in other dialects.

For example, the transgender flag emoji (a single grapheme cluster that happens to be defined by 5 Unicode code points) cannot easily be constructed at the REPL or in a source file without detailed knowledge of the JVM's history (and associated knowledge of UTF-16, an increasingly obsolete character encoding).

Using the documented code points for this grapheme cluster with the JVM's Unicode escaping mechanism does not give the expected outcome:

The correct, but unintuitive solution is to remember that the JVM does not directly support Unicode code points in the supplemental planes, and then to translate the supplemental code point U+1F3F3 into its UTF-16 code unit / surrogate pair representation:

Note: I had to use screenshots for this, since ask.clojure doesn't appear to support Unicode supplemental code points properly either...

Question/request/proposal
Clojure can sidestep this issue in a purely accretive manner, providing better consistency across the JVM and other runtimes, by adding direct support for Unicode literals.

This would involve adding a new literal syntax that represents a single Unicode code point, and perhaps also a new literal syntax that represents a sequence of Unicode code points (perhaps supporting not only the novel Unicode code point literal, but also the existing Character and String literals). Both of these new literals would produce a standard JVM (or JavaScript, or ...) String object, in whatever native encoding those objects employ on their respective platforms - after such literals are read, it's all just the extant String data type - there is no runtime impact.

An example literal syntax

While I am not proposing a specific syntax for these new literals here (though such a task is a necessary step), for illustrative purposes here is an example of what these literals might approximately look like:

Single Unicode code point literals:

#U+0061: produces a String containing the Latin letter a: "a"
#U+1F921: produces a String containing the clown emoji (which ask.clojure cannot display)

Sequences of Unicode code point literals:

#U+[U+0061 U+0020 U+1F921]: produces the 3 grapheme cluster String: "a <clown emoji>"
#U+["a " U+1F921]: produces the same String, but demonstrates why it may be useful to support a mix of literals within the sequence (for readability)
#U+[\a \space U+1F921]: ditto
#U+[U+1F3F3 U+FE0F U+200D U+26A7 U+FE0F]: produces a String containing a single grapheme cluster (the transgender flag emoji)

This final example is an ideal test case, since the transgender flag emoji is a single Unicode grapheme cluster, defined by 5 Unicode code points, but on the JVM (for the historical reason listed originally) is made up of 6 Characters.

Note that the sequence literal may not be necessary, since str could be used with the single code point literal syntax; e.g. (str #U+1F3F3 #U+FE0F #U+200D #U+26A7 #U+FE0F). Whether shifting the cost of string concatenation from read-time to runtime matters or not is another topic worthy of deeper consideration.

Other notes
Orthogonal to this proposal (at least from a Clojure core perspective; from a user perspective they're closely related), it would also be useful if Clojure core (perhaps in the clojure.string namespace) had functions to turn Strings into sequences of code points (as integers) and vice versa. Both the JVM and JavaScript provide native APIs for doing this (and presumably other platforms do too), but providing these as standard functions in Clojure core (similar to what was done with parse-long, parse-double, and parse-boolean in Clojure v1.11) has value and is also purely accretive.

ClojureScript :preloads doesn't work with just cljs.main --repl

Wed, 24 Dec 2025 15:13:56 +0000

Running cljs.main with just --repl doesn't preload whatever is on :preloads.

Given that the quickest way of trying ClojureScript is by running a command like :

clj -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.12.134"}}}}' -M -m cljs.main --repl

it would be great (and I think expected) to be able to run a repl with some dev tooling, like :

clj -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.12.134"} binaryage/devtools {:mvn/version "1.0.7"}}}}' -M -m cljs.main -co '{:preloads [devtools.preload]}' --repl

but it doesn't work.

It reads the file (it complains if you misspell the preload namespace) but then nothing gets loaded.

The problem seems to be related to ClojureScript not compiling the preload namespace when you run with just --repl

If you create a small single file project (like on the start guide) and then do :

clj -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.12.134"} binaryage/devtools {:mvn/version "1.0.7"}}}}' -M -m cljs.main -co '{:preloads [devtools.preload]}' --compile hello-world.core --repl

it works.
After the compile generates the out folder you can run just with --repl and the preload will work.

`(max "x" "y")` used to return "y", now it returns "x"

Mon, 22 Dec 2025 13:45:04 +0000

Hello!

With cljs 1.12.42:

cljs.user=> (max "x" "y")
"y"
cljs.user=>

With cljs 1.12.134:

cljs.user=> (max "x" "y")
"x"
cljs.user=>

Probably related to CLJS-3425 and this commit which added NaN checks:

(defn ^number max
  "Returns the greatest of the nums."
  ([x] x)
  ([x y]
   (cond
     (NaN? x) x
     (NaN? y) y
     (> x y) x
     :else y))
  ([x y & more]
   (reduce max (cljs.core/max x y) more)))

But:

cljs.user=> (NaN? "x")
true
cljs.user=>

Hence the result.

Not sure what the expected result should be since min/max are only supposed to work with numbers but current behavior is surprising.

How does `parents` work for JavaScript inheritance?

Sun, 23 Nov 2025 14:28:23 +0000

Hello

In Clojure, I can do:

(parents String)
; #{java.lang.constant.ConstantDesc java.lang.Object java.lang.CharSequence java.io.Serializable java.lang.constant.Constable java.lang.Comparable}

But in ClojureScript:

(parents js/String)
; nil

ClojureScript's parents doc does mention "JavaScript type inheritance":

Returns the immediate parents of tag, either via a JavaScript type
inheritance relationship or a relationship established via derive. h
must be a hierarchy obtained from make-hierarchy, if not supplied
defaults to the global hierarchy

Is there something wrong with the syntax I used?

Is parents really supposed to work with JavaScript inheritance on ClojureScript?

Possible ClojureScript bug: corner case with regex literal compilation

Sun, 21 Sep 2025 02:59:22 +0000

I've found what I believe to be a bug in ClojureScript regarding compilation of certain regex literals to JavaScript, a specific example being #"(?i)".

In some cases, #"(?i)" will be compiled to the JavaScript syntax //i, which is in fact not a JavaScript regex literal, but rather a JavaScript single line comment. This then comments out all remaining code on the same generated line, resulting in a syntax error when the code is run on a JavaScript runtime.

This minimal unit test example demonstrates the issue:

(ns regex-test
(:require [cljs.test :refer-macros [deftest testing is]]))

(deftest failing-test
(testing "Minimal reproduction"
(is (not (nil? #"(?i)")))))

As a side note, it's worth mentioning that (?i) is not a valid native JavaScript regex in the first place, so I assume ClojureScript is trying to emulate compatibility with JVM regexes (where this is valid), and converting it to the nearest valid JS equivalent - either (?i:) (e.g. at the REPL), or //i (in compiled code, but which is syntactically not a JS regex literal at all).

Is core.async.flow available in ClojureScript?

Thu, 17 Jul 2025 08:31:10 +0000

Hi,

I know it's early days for core.async.flow but I thought I would give it a try in one of my ClojureScript projects.

I've got {:mvn/version "1.9.808-alpha1"} in my deps.edn but I'm getting the following error when I try to access the namespace:

No such namespace: clojure.core.async.flow, could not locate clojure/core/async/flow.cljs

Thanks for your help.

Cannot compile namespace including `+` in clojurescript

Tue, 20 May 2025 10:12:48 +0000

Trying to compile any namespace including + fails in clojurescript

e.g.:

(ns test+.core)

(println "Hello, World!")

compiled with clojurescript "1.12.42"

clj -M --main cljs.main --compile test+.core

results in

 `Namespace test+.core does not exist.`

Trying to include the namespace from another gives:

Unexpected error (ExceptionInfo) compiling at (REPL:1).
No such namespace: test+.core, could not locate test_PLUS_/core.cljs, test_PLUS_/core.cljc, or JavaScript source providing "test+.core" (Please check that namespaces with dashes use underscores in the ClojureScript file name) in file /home/sigvesn/clojure/cljs-test/src/other.cljs

Note that it is possible to compile the namespace from regular clojure.

This is relevant because the clojure walk library uses + in the namespace

Repo with code to reproduce

Bug in Clojurescript string/split with limit?

Wed, 23 Apr 2025 12:03:38 +0000

This seems like a bug to me? Using limit in clojure.string/split (in Clojurescript) gives the wrong result on a simple split.

;; NB Clojurescript
(clojure.string/split "a|b" #"|")
;=> ["a" "|" "b"]
(clojure.string/split "a|b" #"|" 3)
;=> ["" "" "a|b"]

Results should be the same?

Corresponding code in Javascript

"a|b".split(/|/)
;=> ['a', '|', 'b']
"a|b".split(/|/, 3)
;=> ['a', '|', 'b']

Protocol function with placeholder _ arguments doesn't work as in Clojure

Mon, 17 Mar 2025 14:58:32 +0000

A protocol like below will work in Clojure without issue, but in ClojureScript the _'s will apparently (quietly) override each other left to right.

(defprotocol Linkable
  (-href [_ _ _]))

Even if the extend-protocol has unique names for the args, the dispatch seems to happen on the last argument.

Repro at https://github.com/valerauko/proto-repro/commit/a8ad51a225ed44ed134b28a18cc83d272d0d8321

Using distinct argument names in the defprotocol solves the issue. I think if it doesn't / can't work like in JVM Clojure it should warn about this issue.

ClojureScript: Destructuring two keys differing only on dash vs underscore doesn't work

Mon, 03 Feb 2025 16:09:41 +0000

When i try to destructure a key, supporting both kebab and snake case I run in to trouble:

Sometimes both symbols pick up the same value:

(let [{:keys [foo-bar foo_bar] :as m} {:foo_bar 42}]
  [foo-bar (:foo-bar m) foo_bar (:foo_bar m)])
;;=> [42 nil 42 42]

Other times one symbol overshadows the other one:

(let [{:keys [foo-bar foo_bar
              a b c d e f g] :as m} {:foo_bar 42}]
  [foo-bar (:foo-bar m) foo_bar (:foo_bar m)])
;;=> [nil nil nil 42]

At least that's what I think is going on there: foo-bar doesn't exist and gets the value nil, overshadowing the symbol foo_bar for which the value exists.

This is supposedly a known limitation in ClojureScript, but I couldn't find it in the issue tracker. Nor does it seem like ChatGPT knows about it. Maybe it helps a bit to have it visible here for bots and humans alike.

How to get interactive programming back when using shadow-cljs with dynamically rendered html

Fri, 15 Nov 2024 12:04:42 +0000

Hi,

I am generating html dynamically on the server with hiccup. I am using the include-js macro to add the javascript that has been compiled from clojurescript to the hiccup template. The shadow-cljs cli just watches the clojurescript and just compiles the javascript.

But when I use this approach I lose all the interactive programming that I have if I am using shadow-cljs with a statically rendered html file.

Is it possible to get interactive programming with clojurescript where one evaluates expressions on the fly with a repl when using shadow-cljs while generating the html dynamically.

I am assuming shadow-cljs is adding some interactive javascript to the statically rendered file that will make it possible to get the interactivity one wishes to get. Is it possible to add that missing piece to html that one is generating themselves?

ClojureScript compiler does not transpile "es8" closure libraries

Tue, 20 Aug 2024 17:42:31 +0000

The ClojureScript compiler determines the type of the Closure library in the transpile function. However, :es8is not implemented.

I have a fix for this, when a bug number has been assigned.

Thanks,
Hadil

How to load couple of modules with cljs.loader/load?

Sat, 06 Apr 2024 08:19:03 +0000

I didn't expect any problems with the task initially. Just loaded them one by one with cljs.loader/load until....
Until I got 'beforeLoadModuleCode called with module module2 while module module1 is loading'
First I realized that load was asynchronous and module loading wasn't actually finished when load exited. Digging goog.module.ModuleManager left me with an impression that its load() function is capable to queue new module loading until the previous one finishes loading.

My impression that the problem is that cljs.loader/load calls beforeLoadModuleCode() at the wrong moment of time. It seems that it must be called at the very begining of evaluating the module code, not before it even starts to download it as it is now, i.e., setLoaded is the last instruction of the module and beforeLoadModuleCode must be the first.
However, I'm still unsure I'm getting the whole idea behind ModuleManager correctly so I need a confirmation that I'm correct.

Is it possible to get ClojureScript hot reload in a Chrome Extension?

Sat, 16 Mar 2024 14:17:48 +0000

I've been working with Chrome Extensions for some time and it would be amazing to get ClojureScript hot reloading capabilities there.

I tried Thomas Heller example shadow-cljs project for Chrome Extensions and some other stuff that I documented in a minimum example repo, but with no success.

In summary, seems like the Chrome Extensions' v3 manifest prohibits eval, which means we are out of luck?

Thanks!

Clojurescript unable to use arrow constructors in body of defrecord, while Clojure does

Sat, 16 Mar 2024 08:14:12 +0000

I get a warning if I try to compile a defrecord where a method tries to call the arrow constructor.

This:

(defrecord Foo [a b]
  SomeProtocol
  (some-method [_]
    (->Foo new-a new-b)))

gives the message "WARNING: Use of undeclared Var some.ns/->Foo at line X". Clojure accepts this form ok.

If I switch to the dot constructor version, like (Foo. _ _) it compiles.

I noticed that in the clj defrecord macro, the symbols for ->Foo and map->Foo are declared first thing, but in cljs, the related build-positional-factory and build-map-factory fns are called at the end, after emit-defrecord. Perhaps that's the issue?

It looks like deftype should have a similar issue, but I haven't tested it.

cljs.core/test does not work as the docstring describes

Tue, 27 Feb 2024 12:33:17 +0000

cljs.core/test does not work according to its docstring description.

The definition of cljs.core/test is

(defn test
  "test [v] finds fn at key :test in var metadata and calls it,
  presuming failure will throw exception"
  [v]
  (let [f (.-cljs$lang$test v)]
    (if f
      (do (f) :ok)
      :no-test)))

It's intended use, as far as I understand it, is as such (example copied from the documented Clojure version of the same function at ClojureDocs, https://clojuredocs.org/clojure.core/test#example-542692cac026201cdc326b8a ):

(defn my-function
  "this function adds two numbers"
  {:test #(do
            (assert (= (my-function 2 3) 5))
            (assert (= (my-function 4 4) 8)))}
  ([x y] (+ x y)))

(test #'my-function)  ;equal to (test (var my-function))
=> :ok

So, cljs.core/test enables functions to self-document their capabilities via tests made available in metadata under the :test key.

However, repeating the above in a CLJS environment yields a different result:

(defn my-function
  "this function adds two numbers"
  {:test #(do
            (assert (= (my-function 2 3) 5))
            (assert (= (my-function 4 4) 8)))}
  ([x y] (+ x y)))

(test #'my-function)
=> :no-test

The interesting thing is that, given that I evalated the above in a CLJS REPL, the metadata is available, as far as I can tell:

(meta #'my-function)
=>
{:ns cljs.user,
 :name my-function,
 :file "<cljs repl>",
 :end-column 18,
 :source "my-function",
 :column 1,
 :line 1,
 :end-line 1,
 :arglists ([x y]),
 :doc "this function adds two numbers", 
 :test #object[Function]}

This can be made even clearer by substituting the rather opaque function for a keyword:

(defn my-function
  "this function adds two numbers"
  {:test :just-a-keyword}
  ([x y] (+ x y)))

(meta #'my-function)
=>
{:ns cljs.user,
 :name my-function,
 :file "<cljs repl>",
 :end-column 18,
 :source "my-function",
 :column 1,
 :line 1,
 :end-line 1,
 :arglists ([x y]),
 :doc "this function adds two numbers", 
 :test :just-a-keyword}

I spoke to @theller and @hiredman about this on the Clojurians Slack, and they speculated that cljs.core/test has been repurposed to execute the body of deftests, since the two pieces seem to fit together. Observe:

(require '[cljs.test :as test])
(test/deftest foo (test/is (= 1 2)))
=> #'cljs.user/foo

(test foo)
FAIL in () (<NO_SOURCE_FILE>:1:28)
expected: (= 1 2)
  actual: (not (= 1 2))

:ok

The deftest body is executed and the keyword :ok is returned (regardless of the is result), as can also be gathered from reading definition of cljs.core/test.

If it is true that cljs.core/test has been repurposed in this manner, then two things are also true:

A) If it ever were the intent that cljs.core/test should enable testing :test assertions for defns, that no longer holds.
B) The docstring of cljs.core/test is somewhat misleading.

The first bit of the docstring, "test [v] finds fn at key :test in var metadata and calls it", may be technically correct, but mentions no connection with deftest, and therefore somewhat unhelpful.

The second bit of the docstring, ", presuming failure will throw exception", is certainly not correct when used for deftest - the cljs.test/is macro, which I think is fair to say that most deftests use, catches exceptions and reports instead. I think the original intent is that the execption is thrown, so :ok is not returned, but in this context, that construct fails.

The docstring seems to be a carbon copy of the Clojure version, so possibly, it warrants an update. Or maybe cljs.core/test is simply unused and redundant at this point?

What's an ideomatic way to manage state in a library?

Thu, 15 Feb 2024 12:46:36 +0000

I’m porting a JS library to clojure (and, potentially cljs), and I’m struggling with reasoning about local state. Imagine a scenario where you do RPC over websockets, and the server reply contextually depend on what the server had already sent you. You'd want to keep a local cache of the replies from the server, then.

In OOP world it's expected you incapsulate both the socket and the cache and provide the library users an interface that sends RPCs and transparently handles the cache population and pulling results from it. What would be the ideomatic way to do the same in clojure[-script]? Would I just return a map and expect my functions to take it as a first argument, returning the update state along with the rpc result?

Support for js/BigInt

Fri, 09 Feb 2024 13:32:21 +0000

Native support for BigInt in JavaScript has been around since 2020. (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt)

Any chance of support for this in ClojureScript any time soon?

Would be nice to be able to use this as a number in numeric ops and as a key in hash maps.
Also, cljs.core could be extended with functions like bigint and integer? from clojure.core.

BigInts would bring clojurescript one step closer to supporting Ratios.

Do you use arity 3 or higher comparisons such as = < <= > >= == in performance sensitive code?

Tue, 16 Jan 2024 22:14:09 +0000

For comparisons (= < <= > >= ==) arity 3 and higher are much slower than doing e.g. (and (< a b) (< b c)). The arity 3 is in my research rather less common but still used in e.g. Manifold stream.clj [0] or rrb_vector rrbt.clj [1]. Arity 3 is idiomatic in places, where you compare lower and upper bound for a "variable". However, I don't think arity 4 and higher is used much in practical code. At least I haven't found any interesting instances of such a use.

An example implementation (based on the one currently in core) could be:

(defn <'
  "Returns non-nil if nums are in monotonically increasing order,
  otherwise false."
  {:inline         (fn [x y] `(. clojure.lang.Numbers (lt ~x ~y)))
   :inline-arities #{2}
   :added          "1.0"}
  ([x] true)
  ([x y] (. clojure.lang.Numbers (lt x y)))
  ([x y z] (and (<' x y) (<' y z)))
  ([x y z & more]
   (if (<' x y z)
     (if (next more)
       (recur y z (first more) (next more))
       (<' z (first more)))
     false)))

[0] https://github.com/clj-commons/manifold/blob/c3fc69066f3abba0b5ab0f4c2b1c4338bcc61d19/src/manifold/stream.clj#L978
[1] https://github.com/clojure/core.rrb-vector/blob/master/src/main/clojure/clojure/core/rrb_vector/rrbt.clj

ClojureScript and the deprecation of Google Closure Library

Fri, 12 Jan 2024 16:33:30 +0000

Google announced recently that they will be sunsetting the Closure Library (not Closure itself).

Does this impact ClojureScript in any meaningful way?

Thanks!

MUI Select - add deselect function

Wed, 13 Dec 2023 11:43:41 +0000

(defn- menu-item
  [value-fn label-fn state lang index item]
(let [value (value-fn item)
    label (label-fn item lang)]
^{:key index}
[:> m/MenuItem {:value   value
                :data-cy (-> (str value) (str/lower-case) (str/replace " " "-") (str "-menu-item"))}
 [:> m/Checkbox {:checked (= (value-fn state) value)}]
 [:> m/Typography {} label]
 ]))

(defn select
  [{:keys [data state-fn disabled? label value-fn label-fn data-cy variant]}]
  (let [rf-lang   (rf/subscribe [:current-language])
        label-fn1 (or label-fn (fn [item lang] (value-fn item)))]
    (fn [{:keys [data state-fn disabled? label value-fn data-cy variant]}]
      (let [lang  @rf-lang
            state (state-fn)
            props (cond->
                    {:select      true
                     :full-width  true
                     :SelectProps {:MenuProps    {:getContentAnchorEl nil}
                                   :render-value (fn [items]
                                               (if label-fn
                                                 (label-fn state lang)
                                                 (map identity items)))
                               :data-cy      data-cy}
                 :value       (or (value-fn state) "")
                 :on-change   (fn [e]
                                (let [selected (.. e -target -value)]
                                  (state-fn (first (filter #(= selected (value-fn %)) data)))))
                 :label       (i18n/translation label lang)
                 :disabled    disabled?}
                variant (assoc :variant variant))]
    [:> m/TextField props (map-indexed (partial menu-item value-fn label-fn1 state lang) data)]))))

I have the following piece of code to create a dropdown list with items that have a checkbox next to them. The problem is that the checkbox cannot be removed. When the user clicks on an already selected checkbox, nothing happens. And in this case, it should become deselect.

clojure.pprint/pprint bug when using the code-dispatch table

Fri, 10 Nov 2023 14:06:05 +0000

There seams to be a bug in clojure.pprint/pprint when using the code-dispatch table and printing let. It happens on Clojure and ClojureScript.

Clojure 1.11.1
user=> (require '[clojure.pprint :as pp])

user=> 
(binding [pp/*print-pprint-dispatch* pp/code-dispatch]
  (pp/pprint
   '(let)))

((let)) ;; prints some extra parenthesis

(binding [pp/*print-pprint-dispatch* pp/code-dispatch]
  (pp/pprint
   '(let*)))

(let*) ;; doesn't happen when pprinting any other form

Can't add #inst values to var metadata. Error: Not supported: class java.time.Instant

Sat, 07 Oct 2023 19:28:05 +0000

I wasn't able to add #inst values to var metadata. Compilation failed to Not supported: class java.time.Instant error

Steps to reproduce:

$ mkdir src
$ echo '(ns core) (def ^{:time #inst "2023-10-07"} foo :foo)' > src/core.cljs
$ clj -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.11.60"}}}' -M --main cljs.main --compile core

Expected: Compilation is successful

Actual:

Unexpected error compiling at (REPL:1).
Not supported: class java.time.Instant

Full report at:
/var/folders/0p/vtdv4p053pd6gkx8d5p98h000000gn/T/clojure-15941611179751768055.edn

Analysis:

CLJS-3291 changed the #inst reader to produce java.time.Instant instead of java.util.Date. The analysis cache transit writer is failing to write java.time.Instant because it only knows how to serialize java.util.Date.

Workaround:

(def foo :foo)
(alter-meta #'foo assoc :time #inst "2023-10-07")

Full report:

{:clojure.main/message
 "Unexpected error compiling at (REPL:1).\nNot supported: class java.time.Instant\n",
 :clojure.main/triage
 {:file
  #object[java.io.File 0x608f79a8 "/Users/mikko/Documents/Projects/sharetribe/instant-cljs2/src/core.cljs"],
  :clojure.error/phase :compilation,
  :clojure.error/class java.lang.Exception,
  :clojure.error/cause "Not supported: class java.time.Instant"},
 :clojure.main/trace
 {:via
  [{:type clojure.lang.ExceptionInfo,
    :message
    "failed compiling file:/Users/mikko/Documents/Projects/sharetribe/instant-cljs2/src/core.cljs",
    :data
    {:file
     #object[java.io.File 0x608f79a8 "/Users/mikko/Documents/Projects/sharetribe/instant-cljs2/src/core.cljs"],
     :clojure.error/phase :compilation},
    :at
    [cljs.compiler$compile_file$fn__4809 invoke "compiler.cljc" 1768]}
   {:type java.lang.RuntimeException,
    :message
    "java.lang.Exception: Not supported: class java.time.Instant",
    :at
    [com.cognitect.transit.impl.WriterFactory$1
     write
     "WriterFactory.java"
     65]}
   {:type java.lang.Exception,
    :message "Not supported: class java.time.Instant",
    :at
    [com.cognitect.transit.impl.AbstractEmitter
     marshal
     "AbstractEmitter.java"
     195]}],
  :trace
  [[com.cognitect.transit.impl.AbstractEmitter
    marshal
    "AbstractEmitter.java"
    195]
   [com.cognitect.transit.impl.JsonEmitter
    emitMap
    "JsonEmitter.java"
    171]
   [com.cognitect.transit.impl.AbstractEmitter
    emitMap
    "AbstractEmitter.java"
    86]
   [com.cognitect.transit.impl.AbstractEmitter
    marshal
    "AbstractEmitter.java"
    185]
   [com.cognitect.transit.impl.JsonEmitter
    emitMap
    "JsonEmitter.java"
    171]
   [com.cognitect.transit.impl.AbstractEmitter
    emitMap
    "AbstractEmitter.java"
    86]
   [com.cognitect.transit.impl.AbstractEmitter
    marshal
    "AbstractEmitter.java"
    185]
   [com.cognitect.transit.impl.JsonEmitter
    emitMap
    "JsonEmitter.java"
    171]
   [com.cognitect.transit.impl.AbstractEmitter
    emitMap
    "AbstractEmitter.java"
    86]
   [com.cognitect.transit.impl.AbstractEmitter
    marshal
    "AbstractEmitter.java"
    185]
   [com.cognitect.transit.impl.JsonEmitter
    emitMap
    "JsonEmitter.java"
    171]
   [com.cognitect.transit.impl.AbstractEmitter
    emitMap
    "AbstractEmitter.java"
    86]
   [com.cognitect.transit.impl.AbstractEmitter
    marshal
    "AbstractEmitter.java"
    185]
   [com.cognitect.transit.impl.AbstractEmitter
    marshalTop
    "AbstractEmitter.java"
    212]
   [com.cognitect.transit.impl.JsonEmitter emit "JsonEmitter.java" 41]
   [com.cognitect.transit.impl.WriterFactory$1
    write
    "WriterFactory.java"
    62]
   [cljs.vendor.cognitect.transit$write invokeStatic "transit.clj" 171]
   [cljs.vendor.cognitect.transit$write invoke "transit.clj" 168]
   [cljs.analyzer$write_analysis_cache$fn__3960
    invoke
    "analyzer.cljc"
    4771]
   [cljs.analyzer$write_analysis_cache
    invokeStatic
    "analyzer.cljc"
    4770]
   [cljs.analyzer$write_analysis_cache invoke "analyzer.cljc" 4757]
   [cljs.compiler$emit_source invokeStatic "compiler.cljc" 1642]
   [cljs.compiler$emit_source invoke "compiler.cljc" 1557]
   [cljs.compiler$compile_file_STAR_$fn__4778
    invoke
    "compiler.cljc"
    1671]
   [cljs.compiler$with_core_cljs invokeStatic "compiler.cljc" 1477]
   [cljs.compiler$with_core_cljs invoke "compiler.cljc" 1466]
   [cljs.compiler$compile_file_STAR_ invokeStatic "compiler.cljc" 1655]
   [cljs.compiler$compile_file_STAR_ invoke "compiler.cljc" 1648]
   [cljs.compiler$compile_file$fn__4809 invoke "compiler.cljc" 1753]
   [cljs.compiler$compile_file invokeStatic "compiler.cljc" 1728]
   [cljs.compiler$compile_file invoke "compiler.cljc" 1704]
   [cljs.closure$compile_file invokeStatic "closure.clj" 657]
   [cljs.closure$compile_file invoke "closure.clj" 635]
   [cljs.closure$fn__6472 invokeStatic "closure.clj" 731]
   [cljs.closure$fn__6472 invoke "closure.clj" 725]
   [cljs.closure$fn__6381$G__6374__6388 invoke "closure.clj" 553]
   [cljs.closure$compile_sources$iter__6598__6602$fn__6603
    invoke
    "closure.clj"
    1102]
   [clojure.lang.LazySeq sval "LazySeq.java" 42]
   [clojure.lang.LazySeq seq "LazySeq.java" 51]
   [clojure.lang.Cons next "Cons.java" 39]
   [clojure.lang.RT next "RT.java" 713]
   [clojure.core$next__5451 invokeStatic "core.clj" 64]
   [clojure.core$dorun invokeStatic "core.clj" 3143]
   [clojure.core$doall invokeStatic "core.clj" 3149]
   [clojure.core$doall invoke "core.clj" 3149]
   [cljs.closure$compile_sources invokeStatic "closure.clj" 1098]
   [cljs.closure$compile_sources invoke "closure.clj" 1087]
   [cljs.closure$build invokeStatic "closure.clj" 3200]
   [cljs.closure$build invoke "closure.clj" 3104]
   [cljs.build.api$build invokeStatic "api.clj" 231]
   [cljs.build.api$build invoke "api.clj" 212]
   [cljs.cli$default_compile invokeStatic "cli.clj" 530]
   [cljs.cli$default_compile invoke "cli.clj" 486]
   [cljs.cli$compile_opt invokeStatic "cli.clj" 542]
   [cljs.cli$compile_opt invoke "cli.clj" 540]
   [cljs.cli$main invokeStatic "cli.clj" 703]
   [cljs.cli$main doInvoke "cli.clj" 692]
   [clojure.lang.RestFn applyTo "RestFn.java" 139]
   [clojure.core$apply invokeStatic "core.clj" 669]
   [clojure.core$apply invoke "core.clj" 662]
   [cljs.main$_main invokeStatic "main.clj" 65]
   [cljs.main$_main doInvoke "main.clj" 56]
   [clojure.lang.RestFn applyTo "RestFn.java" 137]
   [clojure.lang.Var applyTo "Var.java" 705]
   [clojure.core$apply invokeStatic "core.clj" 667]
   [clojure.main$main_opt invokeStatic "main.clj" 514]
   [clojure.main$main_opt invoke "main.clj" 510]
   [clojure.main$main invokeStatic "main.clj" 664]
   [clojure.main$main doInvoke "main.clj" 616]
   [clojure.lang.RestFn applyTo "RestFn.java" 137]
   [clojure.lang.Var applyTo "Var.java" 705]
   [clojure.main main "main.java" 40]],
  :cause "Not supported: class java.time.Instant",
  :phase :compilation}}

Use transducer arity of `into` in `clojure.walk` namespace

Wed, 13 Sep 2023 22:49:05 +0000

It's simple. Just like that:

> clojure.walk/walk:
(outer (reduce (fn [r x] (conj r (inner x))) form form))
=> (outer (into form (map inner) form))
(outer (into (empty form) (map inner form)))
=> (outer (into (empty form) (map inner) form))

> clojure.walk/keywordize-keys:
(postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)
=> (postwalk (fn [x] (if (map? x) (into {} (map f) x) x)) m)

> clojure.walk/strigify-keys:
(postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)
=> (postwalk (fn [x] (if (map? x) (into {} (map f) x) x)) m)

Clojurescript issue in 1.11.121 and master when compiling

Tue, 12 Sep 2023 22:01:58 +0000

When compiling a file with :

clj -Sdeps '{:paths ["src"] :deps {org.clojure/clojurescript {:mvn/version "1.11.121"}}}' -M -m cljs.main -co '{:main org.foo.myscript}' --compile

the compilation will work fine, but if after that you run cljs.main --repl the browser repl will start, but evaluating forms on it will not work since evaluation will never finish.

This exact same commands work fine in 1.11.60.

After some debugging the issue seems to be caused by the current compiler never adding

document.write('<script>goog.require("clojure.browser.repl.preload");</script>');

to the resulting js file.

This is caused by :

https://github.com/clojure/clojurescript/blob/master/src/main/clojure/cljs/closure.clj#L2500-L2501

not adding the preload because :browser-repl isn't true.

The breaking change comes from this line:

https://github.com/clojure/clojurescript/blob/master/src/main/clojure/cljs/cli.clj#L498

which removes :browser-repl from the options because we are just compiling and there is no repl involved.

Looks like the behavior was explicitly changed by this commit :

https://github.com/clojure/clojurescript/commit/9c01d9b0a70ada1cb17cf3ce65ae93d76d0d3b08

Reverting the commit fixes the issue.

How to transform js/Error to a clojurescript map?

Mon, 21 Aug 2023 14:54:16 +0000

I'm getting a js/Error in my catch form of try/catch. I was doing some repl work to see what I can understand about js/Errors. What I don't understand is why (js->clj js-err) just returns the same js/Error object.

(def js-err (js/Error. "testing"))

js-err
;; => #object[Error Error: testing]
(js->clj js-err)
;; => #object[Error Error: testing]

evaluating js-err and (js->clj js-err) result in the same thing.

Here are the properties on js-err

(.getOwnPropertyNames js/Object js-err)
;; => #js["stack" "message"]

what I want or expect to happen:

(js->clj js-err)
;; => {:message "testing"
;;     :stack "blah\nblah"}

Could someone explain why js->clj doesn't give me the object data as a map, and is there a idiomatic way to accomplish turning that object into a map?

This is in the nodejs host

Setting `warning-handlers` in a config file fails with "Wrong number of args (3) passed to: clojure.lang.Symbol"

Sun, 20 Aug 2023 23:30:21 +0000

This config:

{:main             warning-handlers
 :warning-handlers [cljs.analyzer/default-warning-handler]}

Which set :warning-handlers to the default as listed in https://clojurescript.org/reference/compiler-options#warning-handlers

Compiled using:

clj -M --main cljs.main --compile-opts compile.edn --compile

Fails with:

   {:type clojure.lang.ExceptionInfo,
    :message
    "Wrong number of args (3) passed to: clojure.lang.Symbol at line 1 /Users/danie/matter/source/cljs-config/src/warning_handlers.cljs",
    :data
    {:file
     #object[java.io.File 0x27f8f1cc "/Users/danie/matter/source/cljs-config/src/warning_handlers.cljs"],
     :line 1,
     :column 1,
     :tag :cljs/analysis-error},
    :at [cljs.analyzer$error invokeStatic "analyzer.cljc" 780]}

Full repro here: https://github.com/danieroux/cljs-config

Problem with leiningen and a local library

Sun, 13 Aug 2023 07:35:33 +0000

Hi,

I have two ClojureScript projects. From the first one (html-ui-lib) I created a JAR file with the following commands and installed it in a local repository:

lein with-profile prod jar
lein localrepo install -r /home/muenkel/soft/Global/clojure-repo target/html-ui-lib-0.1.2-SNAPSHOT.jar html-ui-lib 0.1.2-SNAPSHOT

In the second project (via-trans) I try to use this library. For this purpose I have included the library in the project file. Unfortunately, not all files of the JAR file are installed. What am I doing wrong?

Here is the content of the JAR file:

245 Fri Aug 11 00:02:34 CEST 2023 META-INF/MANIFEST.MF
3268 Fri Aug 11 00:02:34 CEST 2023 META-INF/maven/html-ui-lib/html-ui-lib/pom.xml
3183 Fri Aug 11 00:02:34 CEST 2023 META-INF/leiningen/html-ui-lib/html-ui-lib/project.clj
783 Fri Aug 11 00:02:34 CEST 2023 META-INF/leiningen/html-ui-lib/html-ui-lib/README.md
 0 Fri Aug 11 00:02:32 CEST 2023 META-INF/
 0 Fri Aug 11 00:02:32 CEST 2023 META-INF/maven/
 0 Fri Aug 11 00:02:32 CEST 2023 META-INF/maven/html-ui-lib/
 0 Fri Aug 11 00:02:32 CEST 2023 META-INF/maven/html-ui-lib/html-ui-lib/
158 Fri Aug 11 00:02:32 CEST 2023 META-INF/maven/html-ui-lib/html-ui-lib/pom.properties
 0 Fri Aug 11 00:01:30 CEST 2023 public/
 0 Tue Jul 11 23:15:06 CEST 2023 public/css/
2715 Tue Jul 11 23:15:06 CEST 2023 public/css/style.css
151 Sun Mar 26 21:35:54 CEST 2023 public/test.html
 0 Fri Aug 11 00:02:32 CEST 2023 public/cljs-out/
554 Mon Apr 17 22:11:34 CEST 2023 public/index.html
417 Sat Apr 08 23:03:08 CEST 2023 public/devcards.html
 0 Sat Jul 22 23:08:08 CEST 2023 html_ui_lib/
 0 Wed May 10 20:49:58 CEST 2023 html_ui_lib/util/
1100 Wed May 10 20:49:58 CEST 2023 html_ui_lib/util/limit-lines.cljs
1123 Thu May 04 23:27:52 CEST 2023 html_ui_lib/core.cljs
 0 Tue Jul 18 21:06:24 CEST 2023 html_ui_lib/spec/
272 Sun Jun 04 00:13:12 CEST 2023 html_ui_lib/spec/email-value-specs.cljs
1883 Tue Jul 18 21:06:24 CEST 2023 html_ui_lib/spec/value_specs.cljs
213 Wed Jun 07 23:31:32 CEST 2023 html_ui_lib/spec/text_value_specs.cljs
3871 Wed Jun 07 23:14:28 CEST 2023 html_ui_lib/spec/ui-specs.cljs
267 Wed Jun 07 23:26:06 CEST 2023 html_ui_lib/spec/number_value_specs.cljs
185 Sat May 20 23:56:54 CEST 2023 html_ui_lib/spec/date_value_specs.cljs
178 Wed May 31 00:26:16 CEST 2023 html_ui_lib/spec/drop_down_value_specs.cljs
1545 Mon Jul 17 22:55:08 CEST 2023 html_ui_lib/spec/type_specs.cljs
 0 Tue Jul 18 20:59:58 CEST 2023 html_ui_lib/ui/
3234 Tue Jun 06 21:32:30 CEST 2023 html_ui_lib/ui/input_email.cljs
4298 Tue Jul 18 20:59:58 CEST 2023 html_ui_lib/ui/tree_view.cljs
3361 Wed May 24 22:41:30 CEST 2023 html_ui_lib/ui/input_text.cljs
3420 Sat Jun 03 21:42:24 CEST 2023 html_ui_lib/ui/input_date.cljs
6013 Wed Jun 07 23:35:28 CEST 2023 html_ui_lib/ui/input_number.cljs
2029 Wed Jul 12 22:42:44 CEST 2023 html_ui_lib/ui/core.cljs
396 Fri Apr 07 21:19:26 CEST 2023 html_ui_lib/ui/button.cljs
844 Tue Jul 11 23:13:50 CEST 2023 html_ui_lib/ui/output_boolean.cljs
1127 Wed Jul 12 23:57:34 CEST 2023 html_ui_lib/ui/input_checkbox.cljs
276 Sun Apr 23 22:59:54 CEST 2023 html_ui_lib/ui/grid_container.cljs
603 Thu Jun 08 22:50:00 CEST 2023 html_ui_lib/ui/output_number.cljs
1613 Mon Jul 10 21:58:34 CEST 2023 html_ui_lib/ui/input_radio.cljs
381 Sun Apr 09 00:16:22 CEST 2023 html_ui_lib/ui/table.cljs
1775 Sat Jul 01 22:19:10 CEST 2023 html_ui_lib/ui/drop_down_list.cljs
2789 Wed Jun 28 22:57:44 CEST 2023 html_ui_lib/ui/leaf_template.cljs
313 Thu Jun 08 23:19:22 CEST 2023 html_ui_lib/ui/output_text.cljs
2160 Thu Jul 13 23:36:30 CEST 2023 html_ui_lib/ui/input_password.cljs
519 Wed Jun 07 22:44:34 CEST 2023 html_ui_lib/test_runner.cljs
860 Wed Jun 07 22:57:28 CEST 2023 html_ui_lib/number_value_specs_test.cljs
273 Wed May 24 21:17:16 CEST 2023 html_ui_lib/text_value_specs_test.cljs
1090 Tue May 30 23:24:06 CEST 2023 html_ui_lib/value_specs_test.cljs
7280 Wed Jun 07 23:07:38 CEST 2023 html_ui_lib/ui_specs_test.cljs
2274 Wed May 24 21:37:08 CEST 2023 html_ui_lib/type_specs_test.cljs
305 Wed May 24 23:44:04 CEST 2023 html_ui_lib/drop_down_value_specs_test.cljs
260 Sun Mar 26 21:35:54 CEST 2023 html_ui_lib/core_test.cljs

Here, on the other hand, is the content of the directory with the library. As you can see, only the files of the namespace ui are contained here:

via-trans/resources/public/cljs-out/dev/html_ui_lib/
└── ui
    ├── core.cljs
    ├── core.cljs.cache.json
    ├── core.js
    ├── core.js.map
    ├── input_text.cljs
    └── input_text.js

Here is the project.clj file of html_ui_lib:

(defproject html-ui-lib "0.1.2-SNAPSHOT"
:description "FIXME: write this!"
:url "http://example.com/FIXME"
:license {:name "Eclipse Public License"

        :url "http://www.eclipse.org/legal/epl-v10.html"}

:min-lein-version "2.7.1"
:dependencies [[clj-commons/citrus "3.3.0"]

             [cljs-ajax "0.8.1"]
             [funcool/struct "1.4.0"]
             [org.clojure/clojure "1.10.0"]
             [org.clojure/clojurescript "1.11.60"]
             [rum "0.12.10"]]

;;:deps {io.github.clj-kondo/config-rum-rum {:mvn/version "0.12.10"}}
:global-vars {warn-on-reflection true}
;;:global-vars {asserts false}
:source-paths ["src/cljs" "test/cljs"]
:aliases {"fig:build" ["trampoline" "run" "-m" "figwheel.main" "-b" "dev" "-r"]

        "fig:min"   ["run" "-m" "figwheel.main" "-O" "advanced" "-bo" "dev"]
        "prod:build" ["run" "-m" "figwheel.main" "-O" "advanced" "-bo" "prod"]}

:profiles {:dev {:dependencies [[com.bhauman/figwheel-main "0.2.18"]

                              [org.slf4j/slf4j-nop "1.7.30"]
                              [com.bhauman/rebel-readline-cljs "0.1.4"]
                              [devcards "0.2.7"]
                              ;; for informing the linter clj-kondo, that the macros
                              ;; defc etc defines symbols
                              [io.github.clj-kondo/config-rum-rum "1.0.0"]]
               :source-paths ["devcards/cljs"]
               :resource-paths ["target"]
               ;; need to add the compiled assets to the :clean-targets
               :clean-targets ^{:protect false} ["target" "resources/public/cljs-out"]
               #_:global-vars #_{*asserts* false}}
         :prod {:dependencies [[com.bhauman/figwheel-main "0.2.18"]]
                :compiler {:optimizations :advanced
                           :pretty-print false}
                :clean-targets ^{:protect false}
                ["target"
                 "resources/public/cljs-out/prod"
                 "resources/public/cljs-out/prod-main.js"]
                :cljsbuild {:builds
                            [{:source-paths ["src/cljs"]
                              :compiler
                              {:output-to "resources/public/cljs-out/prod-main.js"
                               :optimizations :advanced
                               :pretty-print false}
                              :build nil}]}
                :plugins [[lein-cljsbuild "1.1.8"]]}}

:plugins [[com.github.clj-kondo/lein-clj-kondo "0.2.4"]

        [com.fabiodomingues/lein-clj-depend "0.3.0"] ;; Usage: lein clj-depend
        ;; Detects curcular referencies
        [lein-kibit "0.1.8"] ; Code Analyzer: https://github.com/clj-commons/kibit
                                    ; Anounced better code alternatives
                                    ; Usage: lein kibit
                                    ; Automatic: lein auto kibit
                                    ; With replace: lein kibit --replace --interactive
        ])

Here is the project file of via-trans:

(defproject via-trans "0.1.0-SNAPSHOT"
:description "FIXME: write description"
:url "http://example.com/FIXME"
:dependencies [;;[camel-snake-kebab "0.4.3"] ; Libray used for converting keywords

             [ch.qos.logback/logback-classic "1.4.4"]
             [cljs-ajax "0.8.1"]
             [clj-commons/citrus "3.3.0"]
             ;;[clojure.java-time "1.1.0"]
             ;;[cljc.java-time "RENAMED"]
             [cljc.java-time "0.1.18"]
             [conman "0.9.6"] ; Library used for creating functions from sql
             [cprop "0.1.19"]   ; Configuration
             [devcards "0.2.7"]
             [expound "0.9.0"]
             [funcool/struct "1.4.0"]
             [com.layerware/hugsql "0.5.3"] ; Replacement for conman
             ;[hugsql-adapter-case "0.1.0"] ; case adapter for db table columns 
             [html-ui-lib "0.1.2-SNAPSHOT"]
             [json-html "0.4.7"]
             [luminus-transit "0.1.5"]
             [luminus-undertow "0.1.18"]
             [luminus/ring-ttl-session "0.3.3"]
             [org.mariadb.jdbc/mariadb-java-client "1.1.5"]
             ;;[mysql/mysql-connector-java "8.0.18"]
             [markdown-clj "1.11.3"]
             [metosin/muuntaja "0.6.8"]
             [metosin/reitit "0.5.18"]
             [metosin/ring-http-response "0.9.3"]
             [mount "0.1.16"]
             [nrepl "1.0.0"]
             [org.clojure/clojure "1.11.1"]
             [org.clojure/clojurescript "1.11.60"]
             [org.clojure/tools.cli "1.0.214"]
             [org.clojure/tools.logging "1.2.4"]
             [org.webjars.npm/bulma "0.9.4"]
             [org.webjars.npm/material-icons "1.10.8"]
             [org.webjars/webjars-locator "0.45"]
             [org.webjars/webjars-locator-jboss-vfs "0.1.0"]
             [ring-webjars "0.2.0"]
             [ring/ring-core "1.9.6"]
             [ring/ring-defaults "0.3.4"]
             [rum "0.12.10"]
             [selmer "1.12.55"]]

:min-lein-version "2.0.0"
:source-paths ["src/clj" "src/cljc" "src/cljs" "devcards/cljs"]
:test-paths ["test/clj" "test/cljc" "test/cljs"]
:resource-paths ["resources" "target"]
:clean-targets ^{:protect false} ["target" "resources/public/cljs-out"]
:target-path "target/%s/"
:main ^:skip-aot via-trans.core
:plugins []
:profiles
{:uberjar {:omit-source true

         :aot :all
         :uberjar-name "via-trans.jar"
         :source-paths ["env/prod/clj" ]
         :resource-paths ["env/prod/resources"]}

:dev [:project/dev :profiles/dev]
:test [:project/dev :project/test :profiles/test]
:project/dev {:jvm-opts ["-Dconf=dev-config.edn" ]

              :dependencies [[com.bhauman/figwheel-main "0.2.18"]
                             [com.bhauman/rebel-readline-cljs "0.1.4"]
                             [org.clojure/tools.namespace "1.3.0"]
                             [pjstadig/humane-test-output "0.11.0"]
                             [prone "2021-04-23"]
                             [ring/ring-devel "1.9.6"]
                             [ring/ring-mock "0.4.0"]]
              :plugins      [[com.jakemccrary/lein-test-refresh "0.24.1"]
                             [jonase/eastwood "1.2.4"]
                             ;;[cider/cider-nrepl "0.28.4"] ; ist in .lein/profiles.clj
                             ]   
              :source-paths ["env/dev/clj" ]
              :resource-paths ["env/dev/resources" "target"]
              :repl-options {:init-ns user
                             :timeout 120000}
              :injections [(require 'pjstadig.humane-test-output)
                           (pjstadig.humane-test-output/activate!)]}

:project/test {:jvm-opts ["-Dconf=test-config.edn" ]

              :resource-paths ["env/test/resources"] }

:profiles/dev {}
:profiles/test {}})

Add requiring-resolve to ClojureScript

Tue, 25 Jul 2023 16:49:40 +0000

I'm not sure if there are any technical hurdles in adding requiring-resolve to ClojureScript, but it would be nice to have parity so REPL utilities can be written using it.

Why doesn't `type` in CLJS check `:type` on its arguments meta like CLJ does?

Sun, 23 Jul 2023 14:56:02 +0000

In CLJ a check for :type on the meta happens and then falls back to returning the constructor class. In CLJS only the constructor class is returned. It would be nice to have these consistent for usage with multimethods etc.

ClojureScript doesn't respect the provided :line and :column meta for functions

Fri, 14 Jul 2023 18:03:55 +0000

There is currently a difference between Clojure and ClojureScript in how the readers handle the provided :line and :column meta for forms.

In Clojure:

Clojure 1.11.1
user=> ^{:line 40} (defn foo [])
#'user/foo
user=> (-> #'foo meta :line)
40

while in ClojureScript:

ClojureScript 1.11.60
cljs.user=> ^{:line 40} (defn foo [])
#'cljs.user/foo
cljs.user=> (-> #'foo meta :line)
1

I think this is specially important in ClojureScript where there isn't a way of modifying vars meta.

Tooling like editors, when sending forms to the repl, can use this mechanism to add for example line information when they know it. Keeping this information is important since other stuff like clojure.repl/source depends on it, which currently breaks as soon as you eval a form from your editor.

I added a PR here with one possible solution https://github.com/clojure/clojurescript/pull/210

cljs range fn does odd things with nil, is this a bug?

Thu, 13 Jul 2023 15:24:38 +0000

In Clojure, passing a nil as the first arg to range throws NPE, but in ClojureScript it doesn't and odd things can happen:

(range nil 0)
=> ()
(range nil 1)
=> (nil)
(range nil 2)
=> (nil 1)

What's worse is if you have the start and the step both being nil:

(range 0 0 0)
=> ()
(range nil 0 nil)
INTERNAL REPL ERROR: Got an unexpected reply from relay, check Inspect
Timeout while waiting for result.

This actually evaluates to an infinite seq of nils!

(take 10 (range nil 0 nil))
=> (nil nil nil nil nil nil nil nil nil nil)

:boom:

(also raised for discussion on the clojurians slack)

Should documentation be added to explain the default browser console representation of CLJS collections and seqs?

Thu, 11 May 2023 16:04:18 +0000

Using console.log on a CLJS collection or sequence returns an internal representation of the object that looks like `Object { meta: null, cnt: 3, shift: 5, root: {…}, tail: (3) […], __hash: null, "cljs$lang$protocol_mask$partition0$": 167666463, "cljs$lang$protocol_mask$partition1$": 139268 }`. This seems like an easy pitfall for a beginner since console.log is a standard debugging tool for JS developers. Referring users to something like binaryage/devtools or any of the built-in functions for converting CLJS types to JS types might be helpful.

Why does this work in CLJS but doesn't in JVM Clojure?

Thu, 27 Apr 2023 19:12:03 +0000

This looks like a bug in ClojureScript 1.11.54 :

(conj {} [:a 1] '([:b 2] [:c 3]) '([:d 4]))

In Clojure on the JVM this is an error:

cljs.user> (conj {} [:a 1] '([:b 2] [:c 3]) '([:d 4]))
{:a 1, :b 2, :c 3, :d 4}
cljs.user> :cljs/quit
nil
user> (conj {} [:a 1] '([:b 2] [:c 3]) '([:d 4]))
Execution error (ClassCastException) at user/eval17754 (REPL:25).
class clojure.lang.PersistentVector cannot be cast to class java.util.Map$Entry (clojure.lang.PersistentVector is in unnamed module of loader 'app'; java.util.Map$Entry is in module java.base of loader 'bootstrap')

`specify!` and `set!` silently fail if object is not extensible

Mon, 24 Apr 2023 01:11:19 +0000

specify! implicitly relies on the provided object to be extensible so that protocol implementations can be provided. Here is a quick demonstration from a REPL.

cljs.user> (def obj #js {:current nil})
[#js {:current nil}]
cljs.user> (js/Object.preventExtensions obj)
{"current" nil}
cljs.user> (specify! obj
              IDeref
              (-deref [^js this] (.-current this)))
{"current" nil}

Note that reify does not document this requirement either. This leads to confusing situations where non-extensible objects returned by JavaScript libraries (e.g. React) are unable to be extended and the user has little clue why.

Similarly, set! silently fails when objects are not extensible.

cljs.user> (set! (.-foo obj) "bar")
"bar"
cljs.user> obj
{"current" nil}

goog.object/set is able to detect this and throw an error.

cljs.user> (goog.object/set obj "foo" "bar")    
Execution error (TypeError) at (<cljs repl>:1).
Cannot add property foo, object is not extensible
:repl/exception!

Firefox addon written in cljs can't pass Mozilla's review

Thu, 30 Mar 2023 14:16:58 +0000

Hi everyone,
I have a Firefox addon written cljs with advanced optimization, after submit to addons, the reviews tell me that the zip file I submit is different from what they built from source.

I use diff-so-fancy to compare the generated js file, and I found the main difference are variable names.

So is there any way to ensure generated js are reproducible?

PS: My project source code is here:
https://github.com/jiacai2050/gooreplacer/blob/firefox/cljs-src/project.clj#L76

Feature request: async/await support in CLJS

Mon, 27 Mar 2023 23:57:27 +0000

There is a lot of discussion around the web related to adding ES2018 async/await to ClojureScript, be it feature requests[1][2], proposals[3], or experimentation[4][5].

I am posting this question so there is a central place where people can upvote and bring attention to the Clojure core team, and possibly help prioritize consideration of this feature.

I am aware it is not as easy as adding keywords to emitted JS code. I am aware of workarounds like using macros from promesa, core.async, or kitchen-async. I am also aware that there must be a strong use case for consideration on adding this feature. Everything I've mentioned, and more, has been discussed at one point in the links below.

[1] https://groups.google.com/g/clojurescript/c/scUMhU-ctEM
[2] https://www.reddit.com/r/Clojure/comments/f4nlau/clojurescript_and_asyncawait/
[3] https://observablehq.com/@shaunlebron/proposal-generators-and-async-functions-in-clojurescript#blockers
[4] https://twitter.com/roman01la/status/1155602189311717377
[5] https://twitter.com/borkdude/status/1639579880336621570

Feature request: option to demunge keys in `js->clj` function

Sun, 05 Feb 2023 00:11:40 +0000

I'm dealing with JSON data that always uses snake case. While it is possible to achieve what I want with clojure.walk, I think it would be convenient to add an option to js->clj to not only keywordize keys, but also demunge them, so that "some_key" becomes :some-key.

cljs.js/eval: def not working when using :simple optimization (works with :none/:whitespace)

Wed, 28 Dec 2022 15:51:59 +0000

as the title suggests, def appears to pass through without doing anything.

i.e. "(def x)" succeeds
but "(def x 10)" fails because
"Cannot read properties of undefined (reading 'x')"

article here: https://clojurescript.org/guides/self-hosting

suggests :simple optimization should work

to reproduce: https://github.com/sstraust/ClojureDefRepro (see comments for instructions)

clojurescript cljs.main -t node compilation in recent releases does not create an `out` dir

Thu, 27 Oct 2022 18:07:40 +0000

Hi,

it appears as if there is a regression since cljs 1.10.748+ that when a node compilation is requested without explicitly specifying the outdir, a .cljs_node_repl directory is created as the output dir instead of out.

The default out compilation directory is not mentioned in cljs.main -h help, but it appears to be out by default, and this is backed by statement at the end of https://clojurescript.org/reference/repl-and-main :

Compiling Source

To compile ClojureScript source code, pass the main namespace to
cljs.main via the -c option:

java -cp src:cljs.jar cljs.main -c my-namespace.core

The output will be written to the directory specified via the -d
option (or out if unspecified), or to the file specified via the -o
option.

To reproduce
1. download both clojurescript 1.10.742 and clojuresript 1.10.748 jars, https://github.com/clojure/clojurescript/releases
2. create the getting started hello world program from https://clojurescript.org/guides/quick-start
3. execute java -cp "src;cljs-1.10.748.jar" cljs.main -t node -c hello-world.core, observe that a .cljs_node_repl directory has been created instead of the excpected out dir.

If one runs the same with and earlier version, e.g. java -cp "src;cljs-1.10.742.jar" cljs.main -t node -c hello-world.core they can observe that an out dir is created as expected.

This looks like a regression to me.

Workaround is to explicitly specify the directory, .e.g. java -cp "src;cljs-1.11.60.jar" cljs.main -t node -d out -c hello-world.core

Thanks

How do i install Clojure on my Windows OS Laptop?

Tue, 04 Oct 2022 23:04:29 +0000

I need help on how to install and use my Clojure on my Windows Operating system.

Why does CLJS behave differently inside and outside of a function when using > to compare strings?

Fri, 09 Sep 2022 14:53:04 +0000

When building a custom comparator function in CLJS I encountered some IMO strange behaviour:

When using the > (or similar) function with two strings directly in the REPL I get an :invalid-arithmetic warning and nil is returned (somewhat similar to CLJ that raises an exception). When I do the same inside a function it will return a boolean with no warning at all (CLJ raises an exception)

CLJS:

clj꞉user꞉> (> "A" "Z")
nil
; ------ WARNING - :invalid-arithmetic -------------------------------------------
;  Resource: <eval>:1:1
 cljs.core/>, all arguments must be numbers, got [string string] instead
--------------------------------------------------------------------------------

clj꞉user꞉> ((fn [x y] (> x y)) "A" "Z")
false

CLJ:

user=> (> "A" "Z")
Execution error (ClassCastException) at user/eval3 (REPL:1).
class java.lang.String cannot be cast to class java.lang.Number (java.lang.String and java.lang.Number are in module java.base of loader 'bootstrap')
user=> ((fn [x y] (> x y)) "A" "Z")
Execution error (ClassCastException) at user/eval5$fn (REPL:1).
class java.lang.String cannot be cast to class java.lang.Number (java.lang.String and java.lang.Number are in module java.base of loader 'bootstrap')

Can anyone explain what is going on?

Thanks,
Julian

Could there be a ClojureScript version of core.cache?

Sun, 04 Sep 2022 11:54:10 +0000

CCACHE-42 "Porting core.cache to ClojureScript" was declined for infeasibility in 2018, but the JavaScript situation has improved since then. WeakRef has spread to all MDN-tracked environments except Opera.

Lack of a ClojureScript port of data.priority-map (used by 2 cache types) is another challenge noted by CCACHE-42. An issue for a cljc port of data.priority-map is currently open: DPRIMAP-8.

As more data processing moves into browsers and Node.js, core.cache is one of the rare Clojure gems that is still pinned to the JVM.

Since a cljc port of core.cache is not as infeasible as it used to be (and to formalize an interest in DPRIMAP-8), may we reopen CCACHE-42?

Can't change the HTML DOM

Fri, 02 Sep 2022 09:55:18 +0000

It is happening when I'm learning Web Development with Clojure, Third Edition. At first everything looks fine and nothing to worry about, but when i start turn on my pc again, move into next section, and change the code, the HTML layout doesn't change. It's still "Hello, Auto!" even i restore the code again.

I even do with the backup project, but the output still same.

Here's the code :

(ns guestbook.core)

(-> (.getElementById js/document "content")
    (.-innerHTML)
    (set! "Hello, Auto!"))

and this is the home HTML resources :

{% extends "base.html" %}
{% block content %}
<input id="token" type="hidden" value="{{csrf-token}}" />
<div id="content"></div>
{% endblock %}
{% block page-scripts %}
    {% script "/js/app.js" %}
{% endblock %}

ClojureScript can't handle/catch exceptions from neodoc

Thu, 21 Jul 2022 22:40:23 +0000

The errors thrown by neodoc npm module cause issues for ClojureScript (but not node).

$ java -cp cljs.jar cljs.main --repl-env node
ClojureScript 1.10.758
cljs.user=> (def neodoc (js/require "neodoc"))
#'cljs.user/neodoc
cljs.user=>  (.run neodoc "Usage:\n  foo" (clj->js {:argv []}))                    
#js {}

cljs.user=>  (.run neodoc "Usage:\n  foo" (clj->js {:argv ["bar"] :dontExit true}))
Execution error () at (<cljs repl>:1).
null

cljs.user=> (try (.run neodoc "Usage:\n  foo" (clj->js {:argv ["bar"] :dontExit true})) (catch :default e (prn :e e)))
Execution error (TypeError) at (<cljs repl>:1).
Function.prototype.toString requires that 'this' be a Function

This works in node (albeit the thrown object is strange):

Welcome to Node.js v16.13.2.
Type ".help" for more information.
> neodoc = require("neodoc")
{
  run: [Function: run],
  parse: [Function: parse],
  default: { run: [Function: run], parse: [Function: parse] }
}
> neodoc.run("Usage:\n  foo", {argv: ["bar"], dontExit: true})
Uncaught:
Function {
  message: 'foo: unknown command bar\n' +
    'Usage:\n' +
    '  foo\n' +
    'See foo -h/--help for more information',
  payload: {}
}
> try { neodoc.run("Usage:\n  foo", {argv: ["bar"], dontExit: true}) } catch (e) { console.log("e:", e) }
e: Function {
  message: 'foo: unknown command bar\n' +
    'Usage:\n' +
    '  foo\n' +
    'See foo -h/--help for more information',
  payload: {}
}
undefined

Calva project type: shadow-cljs vs deps.edn + shadow-cljs?

Sat, 21 May 2022 19:46:14 +0000

Hi everyone, I’ve gone through the shadow-cljs quickstart guide in the GitHub repo README and got the desired message in the browser console. Next, I wanted to introduce deps.edn to the project. I had some (self-inflicted) difficulty in jacking in after adding deps.edn.

System details:
OS: WSL2
Java version: OpenJDK 11.0.15
Clojure CLI version: 1.11.1.1113

With only shadow-cljs.edn in the project, said file contents are:

;; shadow-cljs.edn
{:source-paths ["src/dev"
                "src/main"
                "src/test"]
 :dependencies []
 
 :dev-http {8080 "public"}
 :builds {:frontend {:target :browser
                     :modules {:main {:init-fn acme.frontend.app/init}}}}}

At this point, jacking in with Calva using the “shadow-cljs” project type, which both starts and connects to the “:frontend” build, works like a charm.

As mentioned in the first paragraph, I had difficulty with introducing deps.edn to the project.

Add deps.edn to the main project directory with the following contents:

;; deps.edn
{:paths ["src/main"
"src/dev"
"src/test"]

 :aliases
 {:cljs {:extra-deps {thheller/shadow-cljs {:mvn/version "2.19.0"}}}}}

Change shadow-cljs.edn to:

 ;; shadow-cljs.edn
    
 {:deps {:aliases [:cljs]}
        
:dev-http {8080 "public"}
        
:builds {:frontend {:target :browser
:modules {:main {:init-fn acme.frontend.app/init}}}}}

Jacking in with Calva using the “deps.edn + shadow-cljs” project type at this point leads to an error containing “Failed starting cljs repl for build: :frontend. Is the build running and connected?”

The Calva Connection Log also provides information, including: “shadow-cljs has not been started yet!” and “If you have a shadow-cljs server or watch running then you are not connected to that process.”

The build doesn’t seem to have been started. What if we run npx shadow-cljs watch frontend and then tried connecting to the REPL? Same error messages as before.

It turns out I should’ve instead kept using the “shadow-cljs” project type (in which case the addition of deps.edn goes down without a hitch).

This leads me to wonder:

When to use which project type?
Which is preferred for a fullstack
project?

Thanks to Peter and contributors for Calva!

lein fig:build doesn't react on any changes in "src" dir

Mon, 18 Apr 2022 21:46:11 +0000

Hi,

when I run lein fig:build it prints diagnostics like:
[Figwheel] Watching paths: ("test" "src" "src/mypkg") to compile build - dev

But it really doesn't, when I change something in src, it just stays silent, nothing changes in browser also. Irun it in WSL2 and I guess it might be reated to it, because npm builds with watch functionality also didn't do actual watching. Only solution I found is https://ma.rcbla.se/blog/2020/08/gulp-watch-not-firing-with-changed-files-when-run-in-wsl/