shadow-cljs.edn

{:verbose true

 :log {:level :debug}

 ;; :deps {:aliases []}
 :lein {:profile "+cljs"}

 ;; :ssl {}

 :http
 {}

 :dev-http
 {8605 "out/demo-browser/public"
  8606 "out/demo-test-browser"
  8607 {:proxy-url "https://www.google.com"
        :proxy-predicate demo.http/proxy-predicate}}

 :prepl {:browser 12345}

 :plugins [demo.dummy-plugin]

 :socket-repl {:port 8204}

 :npm-deps {:install false}

 :source-paths
 ["src/dev"
  "src/main"
  "src/test"]

 :build-defaults
 {:compiler-options
  {:infer-externs :auto}}

 :FOO #shadow/env ["FOO" :as :int :default 12345]

 :builds
 {:cli
  {:target :node-library
   :exports {:main shadow.cljs.npm.cli/main}
   :output-to "packages/shadow-cljs/cli/dist.js"

   :devtools
   {:enabled false}}

  :create-cli
  {:target :node-script
   :main shadow.cljs.npm.create/main
   :output-to "packages/create-cljs-project/dist/script.js"
   :devtools {:enabled false}}

  :babel-worker
  {:target :node-script
   :main shadow.cljs.npm.babel-worker/main
   :output-to "packages/babel-worker/out/babel-worker.js"
   ;; :output-to "src/ui-release/shadow/cljs/dist/babel-worker.js"
   :js-options
   {:js-package-dirs ["packages/babel-worker/node_modules"]
    :js-provider :require}
   :devtools {:enabled false}}

  :ui
  {:target :browser

   :output-dir "src/ui-release/shadow/cljs/ui/dist/js"
   :dev {:output-dir ".shadow-cljs/ui/js"}
   :asset-path "/js"

   :compiler-options
   {:infer-externs :auto
    :output-wrapper false
    :warnings {:invalid-arithmetic false}
    :fn-invoke-direct true
    :output-feature-set :es7
    :shadow-tweaks true
    :shadow-keywords true}

   :js-options
   {:js-package-dirs ["packages/ui/node_modules"]}

   :module-loader true
   :modules
   {:shared
    {:entries []}
    :main
    {:init-fn shadow.cljs.ui.main/init
     :depends-on #{:shared}
     :preloads [shadow.experiments.grove.dev-support]}

    ;; trying something to split out features not pages
    ;; maybe thats a better pattern overall, should be less config
    :code-editor
    {:entries [shadow.cljs.ui.components.code-editor]
     :depends-on #{:main}}

    :worker
    {:init-fn shadow.cljs.ui.worker/init
     :preloads [shadow.experiments.grove.preload
                shadow.cljs.ui.worker-preload]
     :web-worker true
     :depends-on #{:shared}}}

   :devtools {:browser-inject :main}}

  :build-report
  {:target :browser
   :output-dir "src/ui-release/shadow/cljs/build_report/dist/js"

   :modules
   {:main {:entries [shadow.cljs.build-report.ui]}}

   :js-options
   {:js-package-dirs ["packages/ui/node_modules"]}

   :devtools
   {:enabled false}}

  :devtools-ext
  {:target :chrome-extension
   :extension-dir "packages/chrome-ext"
   :manifest-file "packages/chrome-ext/chrome-manifest.edn"
   :outputs
   {:devtools {:output-type :chrome/shared
               :init-fn shadow.cljs.ui.chrome-ext.devtools/init}
    :panel {:output-type :chrome/shared
            :init-fn shadow.cljs.ui.chrome-ext.panel/init}}}

  ;; test builds

  :browser
  {:target :browser

   :output-dir "out/demo-browser/public/js"
   :asset-path "/js"

   :compiler-options
   {;; :strip-type-prefixes #{"cljs.pprint"}
    :shadow-keywords true
    ;; :output-feature-set :es6
    ;; :output-wrapper false
    ;; :closure-output-charset "US-ASCII"
    :closure-defines
    {demo.browser/FOO "bar"}}

   :build-hooks
   [(shadow.html/copy-file
      "out/demo-browser/index.src.html"
      "out/demo-browser/public/index.html")]

   :dev {:build-options {:auto-require-suffixes ["-specs"]}}

   :module-loader true
   ;; :module-hash-names true
   :modules
   {:base
    {:entries [cljs.core demo.sm-before]
     :depends-on #{}}

    :demo
    {:init-fn demo.browser/init
     :depends-on #{:base}}

    :extra
    {:entries [demo.browser-extra]
     :depends-on #{:demo}}

    :worker
    {:init-fn demo.worker/init
     :depends-on #{:base}
     :web-worker true}}

   :js-options
   {;; :js-provider :external
    :external-index "target/external.js"}

   :devtools
   {:before-load-async demo.browser/stop-from-config
    :after-load demo.browser/start-from-config
    :build-notify demo.browser/custom-notify}}

  :test-esm
  {:target :esm
   :output-dir "out/demo-browser/public/esm-js"
   :modules
   {:shared {}
    :a
    {:exports
     {default demo.esm.a/foo
      foo demo.esm.a/foo}
     :init-fn demo.esm.a/init
     :depends-on #{:shared}}
    :b
    {:exports
     {default demo.esm.b/bar}
     :depends-on #{:shared}}}}

  :now-lambda
  {:target :node-library
   :exports-var demo.now/handler
   :output-to "out/demo-now/index.js"}

  :graal
  {:target :graaljs
   :output-to "out/demo-graal/lib.js"
   :entries [demo.graal]
   :compiler-options {:source-map true}}

  :self-contained-script
  {:target :node-script
   :main demo.script/main
   :js-options
   {:js-provider :shadow
    :keep-native-requires true
    ;; :keep-as-require #{"which"}

    :package-overrides
    {"codemirror"
     {"./lib/codemirror.js" "./addon/runmode/runmode.node.js"}}}

   :output-to "out/demo-script-bundle/script.js"}

  #_#_:browser-single
      {:target :browser

       :output-dir "out/demo-browser-single/public/js"
       :asset-path "/js"

       :compiler-options
       {:closure-defines {demo.browser/FOO "bar"}}

       :modules
       {:demo {:entries [demo.browser]}}

       :devtools
       {:before-load-async demo.browser/stop-from-config
        :after-load demo.browser/start-from-config}}

  :chrome-ext
  {:target :chrome-extension
   ;; https://github.com/google/closure-compiler/issues/1704
   :compiler-options {:closure-output-charset "us-ascii"
                      :source-map-inline true}
   :extension-dir "out/chrome-ext"
   :manifest-file "out/chrome-manifest.edn"}

  :test-browser
  {:target :browser-test
   :test-dir "out/demo-test-browser"}

  :test-node
  {:target :node-test
   :ns-regexp "test.(.+)-test$"
   :ui-driven true
   :output-to "out/demo-test-node/script.js"}

  #_#_:test-fail
      {:target :node-test
       :output-to "out/demo-test-node-fail/script.js"
       :ns-regexp "demo.test-fail"}

  #_#_:test-karma
      {:target :karma
       :output-to "out/demo-karma/test.js"}

  #_#_:sm-test
      {:target :browser

       :output-dir "out/demo-sm-test/public/js"
       :asset-path "/js"

       :compiler-options
       {:source-map true
        :pretty-print false}

       :modules
       {:base
        {:entries
         [cljs.core]
         :depends-on
         #{}}

        :test
        {:entries [demo.sm-test]
         :depends-on #{:base}}}

       :js-options
       {:js-provider :shadow
        :resolve
        {"js-sm-test"
         {:target :file
          :file "test/cjs/js-sm-test.js"}}}

       :devtools
       {:http-root "out/demo-sm-test/public"
        :http-port 8605
        :async-require true
        :enabled false}}

  #_#_:bootstrap-host
      {:target :browser

       :output-dir "out/demo-selfhost/public/simple/js"
       :asset-path "/simple/js"

       :compiler-options
       {:optimizations :simple}

       :modules
       {:base
        {:entries [demo.selfhost.simple]}}

       :devtools
       {:http-root "out/demo-selfhost/public"
        :http-port 8610
        :before-load demo.selfhost.simple/stop
        :after-load demo.selfhost.simple/start}}

  #_#_:bootstrap-worker
      {:target :browser

       :output-dir "out/demo-selfhost/public/worker/js"
       :asset-path "/worker/js"

       :compiler-options
       {:optimizations :simple}

       :modules
       {:base
        {:entries [shadow.cljs.bootstrap.env
                   demo.selfhost.host]}
        :worker
        {:entries [demo.selfhost.worker]
         :depends-on #{:base}
         :web-worker true}}

       :devtools
       {:before-load demo.selfhost.host/stop
        :after-load demo.selfhost.host/start}}

  :bootstrap-support
  {:target :bootstrap
   :output-dir "out/demo-selfhost/public/bootstrap"
   :exclude #{cljs.js}
   :entries [cljs.js demo.macro demo.lib reagent.core]
   :macros []}

  #_#_:js-only
      {:target :browser
       :output-dir "out/demo-js-only/public/js"
       :asset-path "/js"
       :compiler-options
       {:optimizations :simple
        :pretty-print true}
       :modules {:base {:entries [cljs.core
                                  shadow.js]}
                 :main {:entries ["/test/cjs/entry.js"]
                        :depends-on #{:base}}}
       :devtools
       {:enabled false
        :console-support false}}

  #_#_:closure
      {:target :browser
       :output-dir "out/demo-closure/public/js"
       :asset-path "/js"
       :modules {:base {:entries [cljs.core
                                  shadow.js]}
                 :main {:entries [demo.reagent]
                        :depends-on #{:base}}}
       :compiler-options
       {:externs ["test/react.ext.js"
                  "test/react-dom.ext.js"]
        :closure-warnings {:global-this :off}}
       :js-options
       {:js-provider :closure}
       :devtools
       {:http-root "out/demo-closure/public"
        :http-port 7810
        :autoload true}}

  #_#_:closure-es6
      {:target :browser
       :output-dir "out/demo-closure-es6/public/js"
       :asset-path "/js"
       :modules {:main {:entries [demo.closure]}}
       :js-options
       {:js-provider :closure}
       :devtools
       {:http-root "out/demo-closure-es6/public"
        :http-port 7820
        :autoload true}}

  :script
  {:target :node-script
   :main demo.script/main
   :output-to "out/demo-script/script.js"

   :compiler-options
   {:optimizations :simple
    :source-map-use-fs-paths true}

   :devtools
   {:before-load-async demo.script/stop
    :after-load demo.script/start
    :preloads [demo.preload]}}

  :bootstrap-script-host
  {:target :node-script
   :main demo.bootstrap-script/main
   :output-to "out/demo-bootstrap/script.js"

   :compiler-options
   {:optimizations :simple}

   :devtools
   {:enabled false}}

  :bootstrap-script-support
  {:target :bootstrap
   :output-dir "out/demo-bootstrap/bootstrap"
   :exclude #{cljs.js}
   :entries [cljs.js demo.macro]
   :macros []
   :js-options
   {:js-provider :require}}

  :library
  {:target :node-library
   :output-to "out/demo-library/lib.js"
   :exports
   {:hello demo.lib/hello}
   :js-options
   {:js-provider :shadow
    :keep-native-requires true}}

  #_#_:custom
      {:target build/custom

       :output-dir "out/demo-browser/js"
       :asset-path "/js"

       :modules
       {:demo {:entries [demo.browser]}}

       :devtools
       {:before-load demo.browser/stop
        :after-load demo.browser/start}}

  :warnings
  {:target :node-script
   :main demo.warnings/main
   :output-to "out/demo-warnings/script.js"}

  :errors
  {:target :node-script
   :main demo.errors/main
   :output-to "out/demo-errors/script.js"}

  #_#_:foreign
      {:target :browser
       :output-dir "out/demo-foreign/js"
       :asset-path "/js"
       :compiler-options
       {:externs
        ["src/dev/demo/foreign-ext.js"]}
       :modules
       {:main {:entries [demo.foreign]}}}

  :npm
  {:target :npm-module
   :output-dir "out/demo-npm/lib"
   :closure-defines {demo.npm/SOMETHING "BAR"}
   :entries [demo.npm
             #_demo.rel-require]}

  #_#_:azure-fn
      {:target :azure-app
       :fn-map {:simple demo.azure.simple/test-fn}
       :app-dir "out/azure-fn"}

  :expo-ios
  {:target :react-native
   :init-fn demo.fulcro-expo/init
   :output-dir "out/ExpoTest/app"
   :devtools {:autoload true
              :preload [shadow.expo.keep-awake]}}

  :test-rn
  {:target :react-native
   :init-fn demo.rn/init
   :chunks {:foo demo.rn-foo/component}
   :output-dir "out/TestCRNA/app"
   :devtools {:autoload true}}

  #_#_:expo-android
      {:target :expo
       :init-fn demo.rn/init
       :platform "android"
       :expo-root "out/TestCRNA"
       :output-dir "out/TestCRNA/out-android"
       :devtools
       {:http-port 19501
        :http-root "out/TestCRNA/out-android"}}

  :npm-web
  {:target :npm-module
   :runtime :browser
   :entries [demo.repl]
   :output-dir "out/npm-web/src/cljs"}

  #_#_:node-repl-test
      {:target :node-script
       :main shadow.cljs.devtools.client.node-repl/main
       :output-to "out/node-repl-dev/node-repl.js"}

  :dce
  {:target :browser
   :output-dir "target/dce-test"
   :compiler-options
   {:fn-invoke-direct true}
   :modules
   {:core {:entries [cljs.core]}
    :main {:entries [demo.dce]
           :depends-on #{:core}}}
   }

  ;; REQUIRES LEIN PROFILE

  :cljs-tests
  {:target :node-test
   :output-to "out/cljs-tests/runner.js"
   :ns-regexp "cljs.primitives-test" ;; "^cljs(.+)-test$"
   :compiler-options
   {:infer-externs false
    :static-fns true
    ;; this breaks test-cljs-2741
    ;; ({} 1 2 3)
    ;; IFn impl but arity doesn't exist
    ;; :fn-invoke-direct true
    :source-map false}

   :namespaces
   [cljs.apply-test
    cljs.primitives-test
    cljs.destructuring-test
    cljs.new-new-test
    ;; assuming these fail because of node?
    cljs.printing-test
    cljs.seqs-test
    cljs.collections-test
    cljs.hashing-test
    cljs.core-test
    cljs.reader-test
    clojure.string-test
    clojure.data-test
    clojure.datafy-test
    clojure.edn-test
    clojure.walk-test
    cljs.letfn-test
    cljs.reducers-test
    cljs.binding-test
    cljs.macro-test
    cljs.top-level
    cljs.keyword-test
    cljs.ns-test
    cljs.ns-test.foo
    foo.ns-shadow-test
    cljs.import-test
    cljs.pprint
    cljs.spec-test
    cljs.specials-test
    cljs.spec.test-test
    cljs.clojure-alias-test
    cljs.hash-map-test
    cljs.map-entry-test
    cljs.metadata-test
    cljs.pprint-test
    cljs.predicates-test
    cljs.syntax-quote-test
    ;; cljs.tagged-literals-test
    cljs.test-test
    static.core-test
    cljs.recur-test
    cljs.array-access-test
    cljs.inference-test
    cljs.walk-test
    cljs.repl-test
    ;; FIXME: this bricks other tests if they run before this
    ;; cljs.extend-to-native-test
    ]

   :exclude
   #{cljs.npm-deps-test
     cljs.tagged-literals-test
     cljs.printing-test ;; assuming those fail because of node?
     cljs.eval-test
     cljs.invoke-test}}
  }}