Oasis with proper modules

.gitignore

@@ -11,6 +11,7 @@ pom.xml.asc
 .lein-plugins/
 .lein-failures
 .nrepl-port
+.shadow-cljs
 resources/public/js
 *-init.clj
 figwheel_server.log

README.org

@@ -13,19 +13,16 @@ ventures on it...”
 #+BEGIN_SRC bash
 $ npm install # or yarn, you know, whatever
 
-$ lein build-all
+$ lein compile
 
 # samak-cli for console programs
-$ ./samak-cli examples/basic.sk
+$ lein run examples/basic.sk
 
 # samak-ui for electron based ui programs
-
-$ ./samak-ui examples/chuck_norris.sk
+$ npx shadow-cljs start
 
 #+END_SRC
 
-In case you don't have electron installed globally, run =npm run start=.
-
 * Roadmaps
 
 ** Samak

cli_src/cli/node_core.cljs

@@ -1,20 +1,26 @@
 (ns cli.node-core
   (:require [cljs.nodejs    :as nodejs]
             [clojure.string :as str]
+            [cli.runtime    :as rt]
+            [promesa.core   :as prom]
             [samak.repl     :as repl]))
 
 (nodejs/enable-util-print!)
 
 (def fs ^js/fs (nodejs/require "fs"))
 
-(defn load-samak-file [filename]
-  (->> (.readFileSync fs filename)
+(defn load-samak-file [filename rt]
+  (-> (.readFileSync fs filename)
        str/split-lines
-       repl/eval-lines))
+       (rt/eval-lines rt)))
 
 (defn -main [& [filename & args]]
   (if (not-empty filename)
-    (load-samak-file filename)
+    (prom/let [w (rt/make-runtime-remote {:store :remote :id "cli-w1"})
+               rt (rt/make-runtime {:id "cli-main" :env {:connects [w]}})]
+               res (load-samak-file filename rt)
+      res)
+
     (println "Usage: node samak-cli.js <filename>")))
 
 (set! *main-cli-fn* -main)

cli_src/cli/runtime.cljs

@@ -0,0 +1,115 @@
+(ns cli.runtime
+  (:require [cljs.nodejs    :as nodejs]
+            [clojure.string :as str]
+            [clojure.core.async :as a]
+            [promesa.core   :as prom]
+            [cognitect.transit :as t]
+            [metosin.transit.dates :as d]
+            [samak.repl     :as repl]
+            [samak.runtime  :as run]
+            [samak.stdlib   :as std]
+            [samak.builtins :as builtins]
+            [samak.caravan  :as caravan]
+            [samak.pipes    :as pipes]
+            [samak.layout :as layout])
+  (:require-macros [cljs.core.async.macros :refer [go go-loop]]))
+
+(def ui-mock-symbols
+  {'modules/ui :blank
+   'pipes/ui :blank
+   'pipes/events :blank
+   'pipes/mouse :blank
+   'pipes/keyboard :blank})
+
+(def cli-symbols
+  (merge builtins/samak-symbols
+         std/pipe-symbols
+         caravan/symbols
+         ui-mock-symbols
+         layout/layout-symbols
+         ))
+
+(defn make-scheduler []
+  (let [broadcast (pipes/pipe (a/chan) ::main-broadcast)
+        to-rt (pipes/pipe (a/chan) ::main-scheduler)]
+    (println "sched")
+    ;; (handle-update "out" broadcast)
+    ;; (handle-update "in" to-rt)
+    (fn [] [to-rt broadcast])))
+
+(def worker_threads (nodejs/require "worker_threads"))
+
+(defn make-worker
+  ""
+  [url]
+    (println "make worker" (.-isMainThread worker_threads))
+  ;; (println "returning worker: " worker_threads)
+  (let [Worker (.-Worker worker_threads)]
+    (Worker. url)))
+
+(def json-reader (t/reader :json {:handlers d/readers}))
+(defn make-handler
+  ""
+  [from-worker conf]
+  (fn
+    [event]
+    (let [data (t/read json-reader event)]
+      ;; (println "recv from" (:id conf) ":" data)
+      (condp = (:target data)
+        (a/put! from-worker data)))))
+
+(defn handle-send
+  ""
+  [worker c conf]
+  (let [w (t/writer :json {:handlers d/writers})]
+    (go-loop []
+      (let [p (<! c)]
+        ;; (println "send to" (:id conf) p)
+        (.postMessage worker (t/write w p)))
+      (recur))))
+
+(defn make-runtime-remote [conf]
+  (prom/let [to-worker (a/chan)
+             from-worker (a/chan)
+             from-mult (a/mult from-worker)
+             worker (make-worker "./cli/samak-cli-worker.js")]
+    ;; race condition on finished worker code before messaging is set up
+    (handle-send worker to-worker conf)
+    (.on worker "message" (make-handler from-worker conf))
+    {:to to-worker :from from-mult :id (:id conf) :conf conf}))
+
+(defn init-runtime-remote [worker init]
+  (let [p (prom/deferred)
+        from (a/chan)]
+    (a/tap (:from worker) from)
+    (go-loop []
+      (let [m (<! from)]
+        (when (and (= (:target m) :bootstrap))
+          (a/put! (:to worker) {:cmd :init :param init}))
+        (when (and (= (:target m) :load) (= (:data m) 100))
+          (prom/resolve! p true)))
+      (recur))
+    p))
+
+
+(defn make-runtime [conf]
+  (prom/let [in-main (pipes/pipe-chan ::to-main nil)
+             out-main (pipes/pipe-chan ::from-main nil)
+             out-mult (a/mult out-main)
+             rt (run/make-runtime cli-symbols (make-scheduler) (merge {:modules {}} conf))
+             w (first (:connects (:env conf)))]
+    (when w
+      (a/tap out-mult (:to w))
+      (a/tap (:from w) in-main))
+    (pipes/link! (pipes/source in-main) (:scheduler rt))
+    (pipes/link! (:broadcast rt) (pipes/sink out-main))
+    (prom/do!
+     (println "init w")
+     (when w (init-runtime-remote w :foo))
+     (println "done w")
+     (repl/init rt))))
+
+(defn eval-lines
+  ""
+  [lines rt]
+  (repl/eval-lines lines rt))

cli_src/cli/worker.cljs

@@ -0,0 +1,57 @@
+(ns cli.worker-core
+  (:require [cljs.nodejs :as nodejs]
+            [clojure.core.async :as a :refer [<! >! chan close! put!]]
+            [cognitect.transit :as t]
+            [metosin.transit.dates :as d]
+            [samak.helpers :as helpers]
+            [samak.worker :as worker])
+  (:require-macros [cljs.core.async.macros :refer [go go-loop]]))
+
+(def worker_threads (nodejs/require "worker_threads"))
+
+(defn handle-update
+  ""
+  [c]
+  (let [w (t/writer :json {:handlers d/writers})]
+    (go-loop []
+      (let [p (<! c)]
+        (.postMessage (.-parentPort worker_threads) (t/write w {:target :load :data p})))
+      (recur))))
+
+
+(defn handle-request
+  ""
+  [c]
+  (let [w (t/writer :json {:handlers d/writers})]
+    (go-loop []
+      (let [p (<! c)
+            before (helpers/now)]
+        ;; (println "to main" p)
+        (.postMessage (.-parentPort worker_threads) (t/write w p)))
+      (recur))))
+
+(def json-reader (t/reader :json {:handlers d/readers}))
+(defn make-handler
+  ""
+  [in init]
+  (fn
+    [event]
+    (let [data (t/read json-reader event)]
+      ;; (println "worker in" data)
+      (if (= (:cmd data) :init)
+        (helpers/debounce #(init (:param data)))
+        (put! in data)))))
+
+(defn bootstrap
+  ""
+  []
+  (println "bootstrap")
+  (let [loading (chan)
+        in (chan)
+        out (chan)]
+    (handle-update loading)
+    (handle-request out)
+    (.on (.-parentPort worker_threads) "message" (make-handler in #(worker/start-rt loading in out)))
+    (put! out {:target :bootstrap})))
+
+(bootstrap)