I'm building a google app script project. I have clojurescript that wraps the google externs and then some javascript for writing the functions that can be read by the google environment. Google's engine only accepts certain forms: https://developers.google.com/apps-script/guides/v8-runtime And if you want to use custom functions (which we do) then we also have to emit jsdoc's of the correct format, which we've not worked out how to do yet... So for the moment, we hand write that and append it on...

I've gotten this working with cljsbuild But I'd like to use shadow so I can start pulling in npm modules. It would be useful if I can just output a single file which we can then trigger an upload on. Though failing that I can do some bash magic to get the output

you can do this fine in just CLJS?

Yes, with cljsbuild

no, just plain CLJS. no .js file

or I'm missing something. do you have an example of the .js file you are appending?

The environment doesn't understand cljs itself, so not sure what you mean there? They have a format called .gs which is broadly v8 compatible which is what the target is

Sure, let me grab an example

Lambda island did a short writeup if that's helpful as well: https://lambdaisland.com/blog/2016-10-01-clojurescript-and-google-apps-script

ah. I remember something like this

I'd just (js* "onOpen(e) { attendomat.core.create_menu(); }") in my .cljs ns instead of appending it 😛

/**
 * Returns the domain for a given name
 * @param {"Apple"} name The value or range of cells
 *     to lookup the domain for.
 * @return The domain of the website
 * @customfunction
 */
function WEBSITE_LOOKUP(name) {
 Array.isArray(name) ?
        name.map(row => row.map(cell => fetch_sitedata(cell, 'domain'))) :
        fetch_sitedata(name, 'domain');
}

function test_WEBSITE_LOOKUP() {
    Logger.log(String(WEBSITE_LOOKUP("Google")));
}

Does that work for stuff like the above?

If the jsdoc comment is not correctly written out it barfs

hmm yeah for jsdoc it is best to just append manually

:advanced will otherwise kill it

so yeah appending might be best

you could do that in a build hook I guess

I'm trying to work out how to structure this

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

 :dependencies
 [[applied-science/js-interop "0.3.1"]]

 :builds
 {:appscript {:output-to "Code.js"
              :output-dir "target"
              :compiler-options {:externs ["resources/gas.ext.js"]}
              :exports-fn humble-app-script.core/generate-exports
              :js-options {:js-provider :shadow}
              :release {:compiler-options {;:optimizations :whitespace
              																													:pretty-print true}}
														:target :npm-module
														:entries [example.core]}}}

is it :npm-module or :node-library or :browser?

neither 😛

So what should my target be 😃

technically it would be :target :google-appscript or something

that just doesn't exist yet 😛

but that what :target is for. this is neither a browser nor node so none of the above fit.

Ah, so it doesn't call any special functionality based on the target name

Target ":appscript" for build :appscript was not found. The built-in targets are:
  - :browser
  - :browser-test
  - :node-script
  - :node-library
  - :npm-module
  - :karma
  - :bootstrap

targets assume the presence of certain functionality.

well yes. as I said this doesn't exist. someone would need to implement it

Right, what would that require? Or should I just use an existing target?

you can use an existing target but as I you have encountered that will always be a hack and require certain manual tweaks

I don't expect you to implement a custom target but thats what I would do if I had time and actual use for it 😛

Ok, well at the moment I'm trying to generate functions that fulfil this format:

function normalFunction() {}
      async function asyncFunction() {}
      function* generatorFunction() {}

      var varFunction = function() {}
      let letFunction = function() {}
      const constFunction = function() {}

      var namedVarFunction = function alternateNameVarFunction() {}
      let namedLetFunction = function alternateNameLetFunction() {}
      const namedConstFunction = function alternateNameConstFunction() {}

      var varAsyncFunction = async function() {}
      let letAsyncFunction = async function() {}
      const constAsyncFunction = async function() {}

      var namedVarAsyncFunction = async function alternateNameVarAsyncFunction() {}
      let namedLetAsyncFunction = async function alternateNameLetAsyncFunction() {}
      const namedConstAsyncFunction = async function alternateNameConstAsyncFunction() {}

      var varGeneratorFunction = function*() {}
      let letGeneratorFunction = function*() {}
      const constGeneratorFunction = function*() {}

      var namedVarGeneratorFunction = function* alternateNameVarGeneratorFunction() {}
      let namedLetGeneratorFunction = function* alternateNameLetGeneratorFunction() {}
      const namedConstGeneratorFunction = function* alternateNameConstGeneratorFunction() {}

      var varLambda = () => {}
      let letLambda = () => {}
      const constLambda = () => {}

      var varAsyncLambda = async () => {}
      let letAsyncLambda = async () => {}
      const constAsyncLambda = async () => {}

all existing targets are here https://github.com/thheller/shadow-cljs/tree/master/src/main/shadow/build/targets

yeah I do remember that this was a problem

given that the CLJS compiler can't emit that

and (defn ^{:export "onOpen"} my-on-open [e] ...)

What's the best way to proceed, I'd just want to sort of get started, I've got a bunch of js code and a bit of cljs code and I'm slowly porting the js bits over which can be ported...

ends up as a goog.exportSymbol("onOpen", function(e) { ... }) which is not recognized

just append the file seems best to me

Ok, well is there a way to do that internally? I'm currently just using bash to cat and >>

I'd be using cat and >> too

I also need to make sure the output doesn't produce calls to global

https://shadow-cljs.github.io/docs/UsersGuide.html#build-hooks

(defn hook
  {:shadow.build/stage :flush}
  [build-state & args]
  (spit
    (io/file "regular" "out.js")
    (slurp (io/file "file-to-append.js"))
    :append true)
  build-state)

I'm trying to use :target :node-library and it doesn't like this:

'use strict';
var b, a = global;

ReferenceError: global is not defined
(anonymous)	@ 
(anonymous)	@ 
(anonymous)	@ 

looking at the hooks docs you linked

as I said .. :node-library the target EXPECTS a node runtime

you cannot make that go away. this is hardcoded into the target as the name implies

you best bet might be :browser but then disable everything browser related

so :devtools {:enabled false} in the build config

Is that going to have an effect when I'm trying to get a repl working for dev?

yes. no REPL support then

meaning to REPL into the google appscript

but doesn't sound like that would work anyways?

you can open a browser-repl or node-repl anytime. that is not affected in any way

No, but it would be useful to be able to have a local repl

I can then mock some of the environment and then do repl based development, but still compile out a release that goes to the google appscript

yes, that is what I described

Ok, that's good 😃

you can npx shadow-cljs browser-repl anytime. requires no build config or so

Just testing this out

Btw, does the args in the hook you gave contain the final build path?

I'd prefer not to hardcode it like:

(io/file "regular" "out.js")

Or should I check out the build/targets directory on github for how to navigate that 😃

Hmm, not sure why, but it's not generating the export. I've got an included js script file that I'm importing using your example:

(:require ["./entry_points" :as entry-points])

(defn generate-exports []
  #js {:fetch_sitedata entry-points/fetch_sitedata})

:output-to "Code.js"
:exports-fn example/generate-exports

please consult the actual shadow-cljs documentation for the chosen :target

https://shadow-cljs.github.io/docs/UsersGuide.html

ie. :target :browser does not have a :output-to option and neither does it have a :exports-fn option

Ah cool, thanks

I'll do that

and be requiring the entry_points.js you are adding it to your build

which means it'll go through :advanced. which I thought you were trying to avoid?

There's two js files, entry_points.js which has some wrapper code which I'm slowly going to be getting rid of, but probably should go through the pipeline and custom_functions.js which I'm appending

I'll stick js in the appropriate file, but some functions in the entry_points.js need to be called in my clojurescript and for some reason though they're in my :exports-fn example/generate-exports in shadow-cljs.edn, it's not appearing inside the final main.js

I don't know what you are expecting to appear

but :target :node-library recognizes :exports-fn. no other target does, so it will do nothing for those. and the only thing that will appear for :node-library is module.exports = your.ns.generate_exports();

whereas the your.ns.generate_exports() part may be renamed and shortened by :advanced

Ah, sorry, yep that makes sense. I'm mixing up target instructions. Basically my goal is to take some of the functions defined inside entry_points.js and export them so they're available in the final output. Should I just create something like this:

(ns example
  (:require [clojure.string :as str]
            [applied-science.js-interop :as j]
            ["./entry_points" :as entry-points]))

(def ^:export fetch_sitedata entry-points/fetch_sitedata)

;; OR
(defn ^:export fetch_sitedata [] (entry-points/fetch_sitedata))

this is not how this works at all

and not solving your problem in any way either

Fair 😃

by including entry_points like above you are including it as part of the build

meaning it will be fully processed, minimized and everything

so whatever you did there to be app-script specific will be gone

or I'm missing something here

it would make this really much much easier to talk about if you create a repo with some code

standalone partial snippets are just not enough

Yep, just saw this:

n("example.fetch_sitedata", vf.fetch_sitedata);

}).call(this);

Hmm ok let me put together an example case after dinner and poke you in this thread? Would that work?

yes that is the export problem I was referring to above

sure

Thanks

How does this look? I tried to make a minimal example https://github.com/Folcon/example-appscript

just a tip

instead of (println (keys build-state)) in the build hook

try (tap> build-state) and then look at it in

Yea, still not used to tap> in cljs projects

this is clojure code 😉

This is why I want to get shadow working 😃

what are you using to edit code? you should really run a formatter. the shadow-cljs.edn is a complete mess :P

:output-to "Code.js" has no effect for :browser

Normally cursive, but currently sublime as I'm throwing a minimal example together 😃

Yep, I need to generate a single file output, similar to webpack

Which contains a mixture of advanced compilation code + appended js code

this build config will generate this as target/main.js

:output-dir + the keys in the :modules map

Right, so I should use a Makefile or another hook, to copy it to the correct location and append the other file?

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

 :dependencies
 [[applied-science/js-interop "0.3.1"]]

 :builds
 {:appscript
  {:target :browser
   :output-dir "target"
   :modules {:main {:entries [app-script.core]}}
   :devtools {:enabled false}
   :build-hooks [(app-script.hooks/build-hook)]
   :compiler-options {:externs ["resources/gas.ext.js"]}}}

the hook you have now does nothing since it doesn't use the target/main.js file?

But yea, not sure why the function inside the entry_points.js isn't getting exported

btw npx shadow-cljs pom then import pom.xml in cursive as a project

as I keep trying to tell you ... you are importing it into the build. IT WILL BE PROCESSED!

that means that the function it has will be DELETED since it is not referenced anywhere

you can actually export it by writing proper ESM code

so instead of

function mult_vals(a, b) {
  return a * b;
}

export function mult_vals(a, b) {
  return a * b;
}

Ah ok

So just add an export directive in the js will work?

Great

then mult_vals is accessible via entry-points/mult_vals

BUT that still doesn't make :exports do what you want and it never will

this is not how the code is constructed

(def ^:export mult_vals [a b]
  (* a b))

is identical as far as the generated code is concerned. the entire entry_points.js indirection does absolutely nothing

can you explain what exactly you are trying to achieve via that entry_points stuff? like what does the final generated JS need to look like

Sure give me a sec to write it up

So the entry_points.js contains effectively working code that is broadly legacy. When I was porting it to cljs I realised that because app-script has it's own weird formats and rules I'd have to feed it javascript to be able to work around some behaviours. So I split it up into custom_functions.js and the original entry_points.js. The idea was that anything we couldn't just port over that was externally facing could live inside custom_functions.js. Any legacy stuff that was still in the process of being ported over that was internal behaviour could live in entry_points.js which could be called and wrapped by clojurescript code. So we have functions like mult_vals which need to be called by functions in the clojurescript code or by functions in custom_functions.js. But are not by themselves public. I'd prefer to run as much as possible through the closure compiler to minimise / remove stuff we don't need. But in the worst case we can just use simple optimisations for now.

ok so then prepend or append BOTH entry_points.js and custom_functions.js to the output

instead of requiring it just use js/mult_vals or whatever in the CLJS code

since they are global functions that is fine

if you want to include it in the build then you can require it like you did

but it will require adding export in the .js and re-exporting it so app-script can find it WILL NOT WORK!

this is just a limitation in the way the closure compiler treats exported things and there is no way to change that

so you can only :export them and refer to them by the full name via the JS that is not going through the closure compiler

Ok, fair enough does that also work if I'm using them at the repl?

As in if I append / prepend with the hook?

they'll not be available in the REPL in any way

Ok

well you can sort of make them available I guess

create a public folder and put the entry_points.js there

then create a index.html that loads them via <script src="/entry_points.js"> and <script src="/js/main.js">

then in the shadow-cljs.edn add :dev-http {3000 "public"} and set :output-dir "public/js"

Sure

Ok, that makes sense

and will access to the functions via js/mult_vals or whatever

just like the appscript would

Thanks a lot, I'll see if I can use that to fix my project

it works for the first sub dependency

related issue with more details : https://github.com/thheller/shadow-cljs/issues/995

You can't, you can only set up your project to be used as a black box library

Ohh, I see. Thanks for clarifying this up for me.

Well, you can export. https://shadow-cljs.github.io/docs/UsersGuide.html#output-wrapper https://shadow-cljs.github.io/docs/UsersGuide.html#_multiple_static_named_exports