REPL state

Author: borkdude

bb/node_repl_tests.clj

@@ -41,6 +41,10 @@
 (deftest refer-test
   (is (str/includes? (:out (repl "(ns foo (:require [\"fs\" :refer [existsSync]])) (existsSync \"README.md\")")) "true")))
 
+(deftest repl-api-test
+  (let [out (:out (p/shell {:out :string} "node test-resources/js_api.mjs"))]
+    (is (= ["1" "1"]  (str/split-lines out)))))
+
 (defn run-tests [_]
   (let [{:keys [fail error]}
         (t/run-tests 'node-repl-tests)]

index.html

@@ -75,9 +75,13 @@
       let urlParams = new URLSearchParams(window.location.search);
       var repl = JSON.parse(urlParams.get('repl'));
 
+        let compilerState = null;
+        console.log(compilerState);
       let evalCode = async (code) => {
         try {
-        let js = compileString(`(do ${code}\n)`, {repl: repl, "elide-exports": repl, context: repl ? 'return' : 'statement'});
+        let opts = {repl: repl, "elide-exports": repl, context: repl ? 'return' : 'statement'};
+        compilerState = compileStringEx(`(do ${code}\n)`, opts, compilerState);
+        let js = compilerState.javascript;
         if (dev) {
           js = js.replace('squint-cljs/core.js', 'http://' + window.location.host + '/core.js');
         }
@@ -195,7 +199,7 @@
         squintUrl = 'squint-cljs';
       }
       var squint = await(import(squintUrl));
-      var compileString = squint.compileString;
+      var compileStringEx = squint.compileStringEx;
       window.compile = () => {
         let code = editor.state.doc.toString();
         code = '' + boilerplateSrc + '\n\n' + code;

index.js

@@ -1 +1 @@
-export { compileString } from './lib/compiler.js'
+export * from './lib/compiler.js';

shadow-cljs.edn

@@ -10,7 +10,8 @@
    :output-dir "lib"
    :modules
    {:compiler {:exports
-               {compileString squint.compiler/compile-string}}
+               {compileString squint.compiler/compile-string
+                compileStringEx squint.compiler/compileStringEx}}
     ;; this is necessary to move fs, path to a common node module instead of to compiler
     :node {:entries [] :depends-on #{:compiler}}
     :compiler.sci {:depends-on #{:compiler :compiler.node :node}

src/squint/compiler.cljc

@@ -396,73 +396,77 @@
 
 (defn compile-string*
   ([s] (compile-string* s nil))
+  ([s opts] (compile-string* s opts nil))
   ([s {:keys [elide-exports
               elide-imports
               core-alias
               aliases]
        :or {core-alias "squint_core"}
-       :as opts}]
-   (binding [cc/*core-package* "squint-cljs/core.js"
-             cc/*target* :squint
-             *jsx* false
-             cc/*repl* (:repl opts cc/*repl*)]
-     (let [opts (merge {:ns-state (atom {})} opts)
-           imported-vars (atom {})
-           public-vars (atom #{})
-           aliases (atom (merge aliases {core-alias cc/*core-package*}))
-           imports (atom (if cc/*repl*
-                           (format "var %s = await import('%s');\n"
-                                   core-alias cc/*core-package*)
-                           (format "import * as %s from '%s';\n"
-                                   core-alias cc/*core-package*)))]
-       (binding [*imported-vars* imported-vars
-                 *public-vars* public-vars
-                 *aliases* aliases
-                 *jsx* false
-                 *excluded-core-vars* (atom #{})
-                 *cljs-ns* *cljs-ns*
-                 cc/*target* :squint
-                 cc/*async* (:async opts)]
-         (let [transpiled (transpile-string* s (assoc opts
-                                                      :core-alias core-alias
-                                                      :imports imports))
-               imports (when-not elide-imports @imports)
-               exports (when-not elide-exports
-                         (str
-                          (when-let [vars (disj @public-vars "default$")]
-                            (when (seq vars)
-                              (str (format "\nexport { %s }\n"
-                                           (str/join ", " vars)))))
-                          (when (contains? @public-vars "default$")
-                            "export default default$\n")))]
-           {:imports imports
-            :exports exports
-            :body transpiled
-            :javascript (str imports transpiled exports)
-            :jsx *jsx*
-            :ns *cljs-ns*}))))))
+       :as opts} state]
+   (let [opts (merge state opts)]
+     (binding [cc/*core-package* "squint-cljs/core.js"
+               cc/*target* :squint
+               *jsx* false
+               cc/*repl* (:repl opts cc/*repl*)]
+       (let [opts (merge {:ns-state (atom {})} opts)
+             imported-vars (atom {})
+             public-vars (atom #{})
+             aliases (atom (merge aliases {core-alias cc/*core-package*}))
+             imports (atom (if cc/*repl*
+                             (format "var %s = await import('%s');\n"
+                                     core-alias cc/*core-package*)
+                             (format "import * as %s from '%s';\n"
+                                     core-alias cc/*core-package*)))]
+         (binding [*imported-vars* imported-vars
+                   *public-vars* public-vars
+                   *aliases* aliases
+                   *jsx* false
+                   *excluded-core-vars* (atom #{})
+                   *cljs-ns* (:ns opts *cljs-ns*)
+                   cc/*target* :squint
+                   cc/*async* (:async opts)]
+           (let [transpiled (transpile-string* s (assoc opts
+                                                        :core-alias core-alias
+                                                        :imports imports))
+                 imports (when-not elide-imports @imports)
+                 exports (when-not elide-exports
+                           (str
+                            (when-let [vars (disj @public-vars "default$")]
+                              (when (seq vars)
+                                (str (format "\nexport { %s }\n"
+                                             (str/join ", " vars)))))
+                            (when (contains? @public-vars "default$")
+                              "export default default$\n")))]
+             (assoc opts
+                    :imports imports
+                    :exports exports
+                    :body transpiled
+                    :javascript (str imports transpiled exports)
+                    :jsx *jsx*
+                    :ns *cljs-ns*
+                    :ns-state (:ns-state opts)))))))))
+
+#?(:cljs
+   (defn clj-ize-opts [opts]
+     (cond-> opts
+       (:context opts) (update :context keyword)
+       (:ns opts) (update :ns symbol)
+       (:elide_imports opts) (assoc :elide-imports (:elide_imports opts))
+       (:elide_exports opts) (assoc :elide-exports (:elide_exports opts)))))
+
+#?(:cljs
+   (defn compileStringEx [s opts state]
+     (let [opts (js->clj opts :keywordize-keys true)
+           state (js->clj state :keywordize-keys true)]
+       (clj->js (compile-string* s (clj-ize-opts opts) (clj-ize-opts state))))))
 
 (defn compile-string
   ([s] (compile-string s nil))
   ([s opts]
    (let [opts #?(:cljs (if (object? opts)
-                         (cond-> (js->clj opts :keywordize-keys true)
-                           :context (update :context keyword))
+                         (clj-ize-opts opts)
                          opts)
                  :default opts)
          {:keys [javascript]}
          (compile-string* s opts)]
      javascript)))
-
-#_(defn compile! [s]
-    (prn :s s)
-    (let [expr (e/parse-string s {:row-key :line
-                                  :col-key :column
-                                  :end-location false})
-          compiler-env (ana-api/empty-state)]
-      (prn :expr expr (meta expr))
-      (binding [cljs.env/*compiler* compiler-env
-                ana/*cljs-ns* 'cljs.user]
-        (let [analyzed (ana/analyze (ana/empty-env) expr)]
-          (prn (keys analyzed))
-          (prn (compiler/emit-str analyzed))))))