perhaps conditional loading is the issue? why not have a namespace that loads deps in the correct order

like use my-lib.datafy when you have datafy

I’m not sure I follow

what happens if the user doesn’t have datafy?

then they dont include your namespace

my library needs to call clojure.datafy/nav etc.

right so you have a direct dependency on datafy then

yes

then you should be including it as your own dependency

it’s provided by the clojure(script) core library

it’s just not in the clojure.core namespace

sp why not require clojure.datafy?

I’d like my library to support versions of CLJS that don’t have datafy yet with a fallback

e.g. try to require clojure.datafy in the current version of CLJS 🙂 my library will not work. I don’t know how often people upgrade their CLJS version

using datafy means you would require the latest version

i.e. it wont be cross-version compatible, the best thing to do would be to keep all of the datafy code in a single optional namespace that your library consumer could use if they are also on the latest version

so it seems. my question was if there was some way to avoid that, doesn’t seem so

sure you can, but you run the risk of the library-consumer building with an incompatible version of cljs

indeed 😕

the thing about using datafy is that it’s not like spec where it’s a separate lib its actually a language feature

the thing to do in this case would be to run 2 versions of your library that build to different language versions

yeah. my library is already split into a set of adapters that can be installed depending on the platform you’re targeting (browser, node, JVM)

maybe I could split this up further. starts to feel kind of a lot if I have e.g. adapter-web and adapter-web-datafy, for each platform

oh yeah... clojure.datafy will always be loaded before library namespaces, so the tagged-literals hack will work for you

what’s the tagged literals hack?

Basically, tagged literals run at compile time, like macros, but even before macro expansion, so you can slip them into namespace declarations without breaking their specs

I still don’t understand how I would do it

AFAICT custom tagged literals are a PITA to setup in CLJS anyway. I tried it before and couldn’t get it to work

yeah, it's sorta non-trivial

is there a way, on the clojure-side, to detect if an ns is requirable, without causing a compile error when it's not requirable?

If not, then maybe the hack won't work :thinking_face:

Well, you could use *clojure-version*

So like, in some clojure file my/readers.clj put:

(defn new? [[then? else?]]
  (let [v *clojure-version*
        new-enough? (and (<= 1 (:major v)) (<= 10 (:minor v)))]
    (if new-enough?
      then?
      else?)))

but I need to detect if the clojurescript version is correct, not the clojure version

Then you can do:

cljs.user=> #my/new? [1 2]
1

hmmm. If you're using a newer version of CLJS that includes datafy, will the clojure version not be recent enough to have datafy? Not sure

One sec

sure. CLJS doesn't care what version of Clojure you have

and vice versa. I can be on Clojure 1.10 right now, but currently there is no version of CLJS that has datafy 😄

hmm, yeah, even on the latest cljs (git sha, with datafy), if your deps have clojure 1.9, then datafy will be available in cljs but tagged literals will run in an environment with clojure 1.9

yep

Okay, I think I figured it out (I'm interested in if this can work too)

This might work:

(defn datafy-exists? [[then? else?]]
  (let [opts (-> env/*compiler* deref :cljs.analyzer/constant-table
                 keys (->> (filter #{'clojure.datafy})))]
    (if opts
      then?
      else?)))

Then in your tagged_literal.cljc file: my/datafy-exists? my.readers/datafy-exists?

Then cljs.user=> #my/datafy-exists? [1 2] => 1

Then, in your my/core.cljs clojurescript file, do:

(ns my.core
  #my/datafy-exists?
   [(:require [clojure.datafy :as d]
              [cljs.pprint :as pp])
    (:require [cljs.pprint :as pp])])

wow hah 😄

🙂 Lemme know if that pans out for ya

I'll have to see if I can get this to work. last time I tried, I coulnd't get tagged_literal.cljc to be picked up by shadow-cljs

I tested it all on vanilla cljs.main

@lilactown Actually, this works better:

(defn exists? [[extant then? else?]]
  (if (-> env/*compiler* deref :cljs.analyzer/constant-table
        keys str (clojure.string/split #" ") vec (->> (some #{(str extant)})))
    then?
    else?))

Then you do: cljs.user=> #my/exists? [clojure.core.protocols/datafy 1 2] => 1

finicky stuff with evaluation at tagged_literal compile time

oh, btw, you could also use this hack to get around having to use split code bases for node/browser/jvm, which I'm pretty sure you can detect through various means at compile time

I'm not aware of a way to use :closure-defines to affect whether a particular namespace is required in an ns form.

[:> TransitionGroup
        {:component "div"
         :class "list tags collection-view tags-list"
         } 
        (for [tag (state/tags-list state)]
          ^{:key (:id tag)}
          [:> CSSTransition
           {:timeout {:enter 250
                      :exit 150}
            :classNames "tag"}
           [tag-row tag
            (get-in state [:ui/tags (:id tag)])
            (:ui/select-all? state)]])]

I need to run, but I got this working — here’s an example that works.

And the style that goes with it:

[:style
      ".tag-enter { background-color: transparent;}"
      ".tag-enter.tag-enter-active { transition: background-color 250ms ease-out; background-color: #FFFF9B;}"
      ".tag-enter-done { transition: background-color 150ms ease-in; }"
      ".tag-exit { opacity: 0.7; max-height: 200px;}"
      ".tag-exit.tag-exit-active { opacity: 0.01; transition: all 150ms ease-out; max-height: 0px;}"
      ]

Two things — a) you have to wrap things into a TransitionGroup b) you have to give explicit timeouts that match your animations.

I’m using the “community” react-transition-group library, not react-with-addons-whatever. The components themselves have no idea about the animations.

This is only for the case where React will animate deletions/additions to the DOM, I haven’t tried yet anything else.

I upgrade when my cljs compiler does

currently using shadow-cljs

Below is my stack trace:

at cljs.core.MapEntry.cljs$core$IIndexed$_nth$arity$2 (/my-project/.shadow-cljs/builds/test/dev/out/cljs-runtime/cljs/core.cljs:6621:5)
at cljs.core.MapEntry.cljs$core$IFn$_invoke$arity$1 (/my-project/.shadow-cljs/builds/test/dev/out/cljs-runtime/cljs/core.cljs:6570:1)
at Function.<anonymous> (/my-project/.shadow-cljs/builds/test/dev/out/cljs-runtime/my-project/policy/pos.cljs:115:3)
at Function.cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$3 (/my-project/.shadow-cljs/builds/test/dev/out/cljs-runtime/cljs/core.cljs:3866:8)
at Function.cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$2 (/my-project/.shadow-cljs/builds/test/dev/out/cljs-runtime/cljs/core.cljs:3861:6)
at Function.cljs.core.apply.cljs$core$IFn$_invoke$arity$2 (/my-project/.shadow-cljs/builds/test/dev/out/cljs-runtime/cljs/core.cljs:3896:6)
at G__11950__delegate (/my-project/.shadow-cljs/builds/test/dev/out/cljs-runtime/my-project/utils/core.cljs:12:5)
at Function.my-project.utils.core.tracefn.G__11950.cljs$lang$applyTo (/my-project/.shadow-cljs/builds/test/dev/out/cljs-runtime/my-project/utils/core.cljs:11:10)
at Function.cljs.core.apply.cljs$core$IFn$_invoke$arity$2 (/my-project/.shadow-cljs/builds/test/dev/out/cljs-runtime/cljs/core.cljs:3895:10)
at /my-project/.shadow-cljs/builds/test/dev/out/cljs-runtime/my-project/utils/core.cljs:169:48

(def ^:dynamic *trace* [])

(defn tracefn
  [n f]
  (fn [& args]
    (binding [*trace* (conj *trace* n)]
      (try
        (apply f args)
        (catch js/Object e
          (when-not (aget e "trace-printed")
            (prn *trace*)
            (aset e "trace-printed" true))
          (throw e))))))

(defmacro deftraced
  [sym bindings & forms]
  `(def ~sym (tracefn '~sym (fn ~bindings [email protected]))))

[proxy-inv proxy-inv inv-ctx distribute get-distributed-value proxy-inv inv-ctx distribute]