Handling of promises

[isaksky]

The top level for the worker is currently like this:

(defn decode-message [event]
  (condp = (aget (.-data event) "command")
    "channel" (.postMessage js/self (run-function-name (.-data event)))
    "channel-arraybuffer" (post-array-buffer (run-function-name (.-data event)))))  

(defn bootstrap []
  (set! (.-onmessage js/self) decode-message))

If (run-function-name (.-data event)) returns a promise, this won't work. This can be hard to avoid when using code from javascript programmers, for example https://github.com/stephenliberty/excel-builder.js . I think it may be useful to be able to opt into behavior more like this:

(defn decode-message [event]
  (condp = (aget (.-data event) "command")
    "channel"(let [promise (run-function-name (.-data event))]
               (.then promise (fn [data]
                                (.postMessage js/self data))))))
             ...

Or maybe detect if it is a promise, then do something reasonable.

[isaksky]

I ended up changing the worker.cljs file to use continuations:

(def worker-fn-map (atom {}))

(defn register-servant-fn
  ([fn-name f]
   (swap! worker-fn-map assoc (keyword fn-name) {:fn f}))
  ([fn-name f cont-fn]
   (swap! worker-fn-map assoc (keyword fn-name) {:fn f :cont-fn cont-fn})))

(defn default-channel-continue [post-message-fn message-data]
  (post-message-fn message-data))

(defn default-channel-arraybuffer-continue
  "In order to send back an array buffer, your function should return
  a vector with the result as the first item and the arraybuffers to transfer as the second.
  an array of array buffers"
  [post-message-fn message-data]
  (let [[result arraybuffers] message-data]
    (post-message-fn result (clj->js arraybuffers))))

(defn get-default-continue [command]
  (case command
    "channel" default-channel-continue
    "channel-arraybuffer" default-channel-arraybuffer-continue))

(defn post-message
  ([data] (.postMessage js/self data))
  ([data1 data2] (.postMessage js/self data1 data2)))

(defn handle-message [event]
  (let [message-data (.-data event)
        fn-key (reader/read-string (aget message-data "fn"))
        fn-opts (get @worker-fn-map fn-key)
        cont-fn (get fn-opts :cont-fn
                     (get-default-continue (aget message-data "command")))
        f (get fn-opts :fn)
        args (aget message-data "args")
        result (apply f args)]
    (cont-fn post-message result)))

(defn bootstrap []
  (set! (.-onmessage js/self) handle-message))

This required a minor change to the f->key function in core.cljs:

(defn f->key [f]
  (ffirst (filter (fn [[k v]] (= f (get v :fn))) @worker/worker-fn-map)))

So then for these cases, you use it like this, for example:

(defn ^:export create-excel-workbook [cols rows]
  (export-to-excel cols rows))

(worker/register-servant-fn
 "create-excel-workbook"
 create-excel-workbook
 (fn [send-fn promise]
   (.then promise (fn [d] (send-fn d)))))

Otherwise, it should be like before.