@makano/rew 1.1.5 → 1.1.6

package/build.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+opath=./bin/ui
+if [ $1 ]; then
+  opath=$1
+fi
+g++ ./cpp/ui.cpp -o $opath `pkg-config --cflags --libs gtk+-3.0 webkit2gtk-4.0 libwebsockets jsoncpp`

package/cpp/ui.cpp

@@ -0,0 +1,217 @@
+#include <gtk/gtk.h>
+#include <webkit2/webkit2.h>
+#include <json/json.h>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <fstream>
+#include <thread>
+#include <sys/inotify.h>
+#include <unistd.h>
+#include <vector>
+
+struct AppData
+{
+  GtkWidget *window;
+  WebKitWebView *web_view;
+  WebKitUserContentManager *content_manager;
+};
+
+static void handle_json_message(const Json::Value &json, AppData *user_data)
+{
+  if (json.isMember("action") && json.isMember("data"))
+  {
+    std::string action = json["action"].asString();
+    std::string data = json["data"].asString();
+
+    // std::cout << action << std::endl;
+
+    if (action == "setTitle")
+    {
+      gtk_window_set_title(GTK_WINDOW(user_data->window), data.c_str());
+    }
+    else if (action == "log")
+    {
+      g_print("%s\n", data.c_str());
+    }
+    else if (action == "HTML")
+    {
+      webkit_web_view_load_html(user_data->web_view, data.c_str(), NULL);
+      g_print("SETUP::HTML");
+    }
+    else if (action == "JS")
+    {
+      webkit_web_view_run_javascript(user_data->web_view, data.c_str(), NULL, NULL, NULL);
+    }
+    else if (action == "JS2")
+    {
+      const char *js_code = g_strdup_printf("%s;", data.c_str());
+      WebKitUserScript *user_script = webkit_user_script_new(js_code,
+                                                             WEBKIT_USER_CONTENT_INJECT_ALL_FRAMES,
+                                                             WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START,
+                                                             NULL, NULL);
+      webkit_user_content_manager_add_script(user_data->content_manager, user_script);
+    }
+  }
+  else
+  {
+    g_print("Invalid JSON format: 'action' and 'data' fields are required\n");
+  }
+}
+
+static void js_callback(WebKitUserContentManager *manager,
+                        WebKitJavascriptResult *js_result,
+                        gpointer user_data)
+{
+  JSCValue *value = webkit_javascript_result_get_js_value(js_result);
+  if (jsc_value_is_string(value))
+  {
+    char *str_value = jsc_value_to_string(value);
+
+    Json::Value root;
+    Json::CharReaderBuilder builder;
+    std::string errors;
+    std::istringstream json_stream(str_value);
+    bool success = Json::parseFromStream(builder, json_stream, &root, &errors);
+
+    if (success)
+    {
+      handle_json_message(root, static_cast<AppData *>(user_data));
+    }
+    else
+    {
+      g_print("%s", str_value);
+    }
+
+    g_free(str_value);
+  }
+}
+
+void watch_file(const std::string &file_path, AppData *app_data)
+{
+  int inotify_fd = inotify_init();
+  if (inotify_fd < 0)
+  {
+    perror("inotify_init");
+    return;
+  }
+
+  int watch_fd = inotify_add_watch(inotify_fd, file_path.c_str(), IN_MODIFY);
+  if (watch_fd < 0)
+  {
+    perror("inotify_add_watch");
+    close(inotify_fd);
+    return;
+  }
+
+  const size_t event_size = sizeof(struct inotify_event);
+  const size_t buf_len = 1024 * (event_size + 16);
+  std::vector<char> buffer(buf_len);
+
+  while (true)
+  {
+    int length = read(inotify_fd, buffer.data(), buf_len);
+    if (length < 0)
+    {
+      perror("read");
+      break;
+    }
+
+    for (int i = 0; i < length;)
+    {
+      struct inotify_event *event = reinterpret_cast<struct inotify_event *>(&buffer[i]);
+      if (event->mask & IN_MODIFY)
+      {
+        std::ifstream file(file_path);
+        std::stringstream buffer;
+        buffer << file.rdbuf();
+        std::string content = buffer.str();
+        file.close();
+
+        if (!content.empty())
+        {
+          Json::Value root;
+          Json::CharReaderBuilder builder;
+          std::string errors;
+          std::istringstream json_stream(content);
+          bool success = Json::parseFromStream(builder, json_stream, &root, &errors);
+
+          // std::cout << "CONTENT DETECTED" << std::endl;
+
+          if (success)
+          {
+            handle_json_message(root, app_data);
+          }
+          else
+          {
+            g_print("Failed to parse JSON string: %s\n", errors.c_str());
+          }
+
+          std::ofstream clear_file(file_path, std::ofstream::out | std::ofstream::trunc);
+          clear_file.close();
+        }
+      }
+      i += event_size + event->len;
+    }
+  }
+
+  close(watch_fd);
+  close(inotify_fd);
+}
+
+int main(int argc, char **argv)
+{
+  if (argc != 2)
+  {
+    g_print("Usage: %s <RUNID>\n", argv[0]);
+    return 1;
+  }
+
+  const char *rid = argv[1];
+  std::string file_path = "/tmp/" + std::string(rid) + ".ruw.ui.socket";
+
+  AppData app_data;
+
+  gtk_init(&argc, &argv);
+
+  GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title(GTK_WINDOW(window), "WebKit Example");
+  gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
+
+  app_data.window = window;
+
+  WebKitUserContentManager *content_manager = webkit_user_content_manager_new();
+  webkit_user_content_manager_register_script_message_handler(content_manager, "external");
+  g_signal_connect(content_manager, "script-message-received::external", G_CALLBACK(js_callback), &app_data);
+  app_data.content_manager = content_manager;
+
+  const char *js_code = g_strdup_printf("window.RUNID = \"%s\";", rid);
+  WebKitUserScript *user_script = webkit_user_script_new(js_code,
+                                                         WEBKIT_USER_CONTENT_INJECT_ALL_FRAMES,
+                                                         WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START,
+                                                         NULL, NULL);
+  webkit_user_content_manager_add_script(content_manager, user_script);
+
+  WebKitWebView *web_view = WEBKIT_WEB_VIEW(webkit_web_view_new_with_user_content_manager(content_manager));
+  gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(web_view));
+  app_data.web_view = web_view;
+
+  webkit_web_view_load_html(web_view, "Loading...", NULL);
+
+  GIOChannel *channel = g_io_channel_unix_new(fileno(stdin));
+  GIOFlags flags = static_cast<GIOFlags>(g_io_channel_get_flags(channel) | G_IO_FLAG_NONBLOCK);
+  g_io_channel_set_flags(channel, flags, NULL);
+
+  g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
+
+  std::thread watch_thread(watch_file, file_path, &app_data);
+
+  g_print("INIT::READY");
+
+  gtk_widget_show_all(window);
+  gtk_main();
+
+  watch_thread.detach();
+
+  return 0;
+}

package/cpp/ui1.cpp

@@ -0,0 +1,101 @@
+#include <gtk/gtk.h>
+#include <webkit2/webkit2.h>
+#include <json/json.h>
+
+struct AppData {
+    const char* url;
+    GtkWidget* window;
+};
+
+static void handle_json_message(const Json::Value& json, AppData* user_data) {
+    // Check if the JSON object has the "action" and "data" fields
+    if (json.isMember("action") && json.isMember("data")) {
+        std::string action = json["action"].asString();
+        std::string data = json["data"].asString();
+
+        // Perform actions based on the received data
+        if (action == "setTitle") {
+            // Set the GTK window's title
+            gtk_window_set_title(GTK_WINDOW(user_data->window), data.c_str());
+        } else if (action == "log") {
+            // Set the GTK window's title
+            g_print("%s\n", data.c_str());
+        } else {
+            // Handle other actions as needed
+        }
+    } else {
+        // Invalid JSON format
+        g_print("Invalid JSON format: 'action' and 'data' fields are required\n");
+    }
+}
+
+static void js_callback(WebKitUserContentManager* manager,
+                        WebKitJavascriptResult* js_result,
+                        gpointer user_data) {
+    JSCValue* value = webkit_javascript_result_get_js_value(js_result);
+    if (jsc_value_is_string(value)) {
+        char* str_value = jsc_value_to_string(value);
+        
+        Json::Value root;
+        Json::CharReaderBuilder builder;
+        std::string errors;
+        std::istringstream json_stream(str_value);
+        bool success = Json::parseFromStream(builder, json_stream, &root, &errors);
+
+        if (success) {
+            // Handle the incoming JSON message
+            handle_json_message(root, static_cast<AppData*>(user_data));
+        } else {
+            g_print("%s", str_value);
+            // g_print("Failed to parse JSON string: %s\n", errors.c_str());
+        }
+
+        g_free(str_value);
+    }
+}
+
+
+int main(int argc, char** argv) {
+    if (argc != 3) {
+        g_print("Usage: %s <URL> <RUNID>\n", argv[0]);
+        return 1;
+    }
+
+    const char* url = argv[1];
+    const char* rid = argv[2];
+
+    AppData app_data;
+    app_data.url = url;
+
+    gtk_init(&argc, &argv);
+
+    GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_window_set_title(GTK_WINDOW(window), "WebKit Example");
+    gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
+
+    app_data.window = window;
+
+    WebKitUserContentManager* content_manager = webkit_user_content_manager_new();
+    webkit_user_content_manager_register_script_message_handler(content_manager, "external");
+    g_signal_connect(content_manager, "script-message-received::external", G_CALLBACK(js_callback), &app_data);
+
+    const char* js_code = g_strdup_printf("window.RUNID = \"%s\";", rid);
+    WebKitUserScript* user_script = webkit_user_script_new(js_code,
+                                                           WEBKIT_USER_CONTENT_INJECT_ALL_FRAMES,
+                                                           WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START,
+                                                           NULL, NULL);
+    webkit_user_content_manager_add_script(content_manager, user_script);
+
+    WebKitWebView* web_view = WEBKIT_WEB_VIEW(webkit_web_view_new_with_user_content_manager(content_manager));
+    gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(web_view));
+
+    webkit_web_view_load_uri(web_view, url);
+  
+    g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
+
+    gtk_widget_show_all(window);
+
+    gtk_main();
+
+    return 0;
+}

package/cpp/ui2.cpp

@@ -0,0 +1,105 @@
+#include <gtk/gtk.h>
+#include <libwebsockets.h>
+#include <json/json.h>
+#include <iostream>
+#include <string>
+#include <map>
+
+std::map<std::string, GtkWidget *> widgets;
+
+static void on_button_clicked(GtkWidget *widget, gpointer data)
+{
+  // Send event back to Node.js server
+  std::string id = static_cast<char *>(data);
+  std::string message = "{\"event\": \"buttonClicked\", \"id\": \"" + id + "\"}";
+  lws_write(static_cast<lws *>(data), (unsigned char *)message.c_str(), message.length(), LWS_WRITE_TEXT);
+}
+
+static int callback_websocket(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len)
+{
+  switch (reason)
+  {
+  case LWS_CALLBACK_CLIENT_ESTABLISHED:
+    std::cout << "Connected to server" << std::endl;
+    break;
+  case LWS_CALLBACK_CLIENT_RECEIVE:
+  {
+    std::string message(static_cast<char *>(in), len);
+    Json::CharReaderBuilder rbuilder;
+    Json::Value root;
+    std::string errors;
+
+    std::istringstream s(message);
+    std::string doc;
+    std::getline(s, doc);
+    std::istringstream ss(doc);
+    if (Json::parseFromStream(rbuilder, ss, &root, &errors))
+    {
+      std::string action = root["action"].asString();
+
+      if (action == "createButton")
+      {
+        GtkWidget *button = gtk_button_new_with_label(root["label"].asString().c_str());
+        g_signal_connect(button, "clicked", G_CALLBACK(on_button_clicked), strdup(root["id"].asString().c_str()));
+        widgets[root["id"].asString()] = button;
+        gtk_container_add(GTK_CONTAINER(gtk_window_new(GTK_WINDOW_TOPLEVEL)), button);
+        gtk_widget_show_all(button);
+      }
+    }
+    break;
+  }
+  case LWS_CALLBACK_CLIENT_CLOSED:
+    std::cout << "Disconnected from server" << std::endl;
+    break;
+  default:
+    break;
+  }
+  return 0;
+}
+
+static const struct lws_protocols protocols[] = {
+    {
+        "example-protocol",
+        callback_websocket,
+        0,
+        1024,
+    },
+    {NULL, NULL, 0, 0}};
+
+int main(int argc, char **argv)
+{
+  std::cout << "Starting" << std::endl;
+  if (argc != 2)
+  {
+    std::cerr << "Usage: " << argv[0] << " <WebSocket server URI>" << std::endl;
+    return 1;
+  }
+
+  gtk_init(&argc, &argv);
+
+  struct lws_context_creation_info info;
+  memset(&info, 0, sizeof info);
+  info.port = CONTEXT_PORT_NO_LISTEN;
+  info.protocols = protocols;
+
+  struct lws_context *context = lws_create_context(&info);
+
+  struct lws_client_connect_info ccinfo = {0};
+  ccinfo.context = context;
+  ccinfo.address = argv[1];
+  ccinfo.port = 8080;
+  ccinfo.path = "/";
+  ccinfo.host = lws_canonical_hostname(context);
+  ccinfo.origin = "origin";
+  ccinfo.protocol = protocols[0].name;
+
+  struct lws *wsi = lws_client_connect_via_info(&ccinfo);
+
+  while (lws_service(context, 1000) >= 0)
+  {
+    gtk_main_iteration_do(false);
+  }
+
+  lws_context_destroy(context);
+  return 0;
+}

package/lib/rew/cli/cli.js

@@ -3,7 +3,7 @@
 const yargs = require('yargs/yargs');
 const path = require('path');
 const { hideBin } = require('yargs/helpers');
-const { fork, exec } = require('child_process');
+const { fork, exec, execSync } = require('child_process');
 const { watch } = require('chokidar');
 const utils = require('./utils');
 const { existsSync, readFileSync, writeFileSync, mkdirSync } = require('fs');
@@ -98,6 +98,17 @@ yargs(hideBin(process.argv))
       utils.createProject(argv.path);
     }
   )
+  .command('ui-bin <path>',  'Build the UI bin for your own app', (yargs) => {
+    yargs
+      .positional('path', {
+        describe: 'Path of the output bin',
+        type: 'string',
+      });
+    },
+    (argv) => {
+      execSync('sh '+path.resolve(__dirname, '../../../build.sh')+' '+argv.path);
+    }
+  )
   .command('run <path | package>',  'Run an app', (yargs) => {
     yargs
       .positional('path', {

package/lib/rew/cli/utils.js

@@ -72,15 +72,16 @@ module.exports = {
         fs.writeFileSync(path.join(projectPath, '.gitignore'), `node_modules/\npackage-lock.json`);
         execSync('cd '+projectPath+' && git init .');
       }
-      log('Installing '+npm_package_name);
-      exec('cd '+projectPath+' && npm i '+npm_package_name, (err) => {
-        if(err){
-          console.error(err);
-          process.exit(0);
-        } else {
-          rl.close();
-        }
-      });
+      // log('Installing '+npm_package_name);
+      // exec('cd '+projectPath+' && npm i '+npm_package_name, (err) => {
+      //   if(err){
+      //     console.error(err);
+      //     process.exit(0);
+      //   } else {
+      //     rl.close();
+      //   }
+      // });
+      log('Done.', ':end');
     }
     if (!fs.existsSync(projectPath)) {
       rl.question(logget('Package Name: '), (pkg) => {

package/lib/rew/const/opt.js

@@ -2,7 +2,8 @@ const execOptions = {
   sharedContext: true,
   resolveExtensions: [{ext: '.js', options: { type: 'js' }}, '.coffee'],
   nativeRequire: false,
-  cwdAlias: '$'
+  cwdAlias: '$',
+  jsxPragma: 'createElement'
 }
 
 module.exports.execOptions = execOptions;

package/lib/rew/functions/fs.js

@@ -13,6 +13,10 @@ module.exports = (currentFile) => {
     return fs.readFileSync(gp(filepath), options);
   }
 
+  function realpath(filepath, options = { encoding: 'utf-8' }){
+    return gp(filepath);
+  }
+
   function write(filepath, content, options){
     return fs.writeFileSync(gp(filepath), content, options);
   }
@@ -49,6 +53,7 @@ module.exports = (currentFile) => {
     fstat,
     exists,
     write,
-    read
+    read,
+    realpath
   };
 } 

package/lib/rew/functions/import.js

@@ -14,17 +14,18 @@ const lookUpInOtherApps = (fullPath) => {
   const name = fullPath.indexOf('/') ? fullPath.split('/')[0] : fullPath;
   let dpath = fullPath.indexOf('/') ? fullPath.split('/')[1] : '';
   let ppath = path.join(con.CONFIG_PATH, name, 'app');
-  if(!existsSync(ppath)) return null;
-  if(!dpath){
+  if (!existsSync(ppath)) return null;
+  if (!dpath) {
     dpath = jsYaml.load(readFileSync(path.join(ppath, 'app.yaml'), 'utf-8')).entry;
   }
   ppath = path.join(ppath, dpath);
-  if(existsSync(ppath)) return ppath;
+  if (existsSync(ppath)) return ppath;
   else return null;
 }
 
 module.exports.imp = function (runPath, context) {
   return function (filename, options = {}) {
+    if (!options) options = {};
     let type = options.type || "coffee";
     let exports,
       ispkg = findPackage(filename);
@@ -35,24 +36,24 @@ module.exports.imp = function (runPath, context) {
 
     const lookUp = () => {
       const otherPath = lookUpInOtherApps(filename);
-      if(!otherPath) throw new Error('Module "'+filename+'" not found');
+      if (!otherPath) throw new Error('Module "' + filename + '" not found');
       else filepath = otherPath;
     }
 
     const foundCache = cachedFiles.find(f => f.filepath == filepath);
 
-    if(!ispkg && foundCache){
+    if (!ispkg && foundCache) {
       exports = foundCache.exports;
     }
 
-    if(!ispkg && !existsSync(filepath)){
-      if(Array.isArray(execOptions.resolveExtensions) && execOptions.resolveExtensions.length){
-        const resolve = execOptions.resolveExtensions.find(ext => typeof ext == "string" ? existsSync(filepath+ext) : existsSync(filepath+(ext.ext || '')));
-        if(resolve) {
+    if (!ispkg && !existsSync(filepath)) {
+      if (Array.isArray(execOptions.resolveExtensions) && execOptions.resolveExtensions.length) {
+        const resolve = execOptions.resolveExtensions.find(ext => typeof ext == "string" ? existsSync(filepath + ext) : existsSync(filepath + (ext.ext || '')));
+        if (resolve) {
           filepath += typeof resolve == "string" ? resolve : resolve.ext;
-          if(typeof resolve == "object" && resolve.options){
-            if(resolve.options.type) type = resolve.options.type;
-            for(let i in resolve.options) options[i] = resolve.options[i];  
+          if (typeof resolve == "object" && resolve.options) {
+            if (resolve.options.type) type = resolve.options.type;
+            for (let i in resolve.options) options[i] = resolve.options[i];
           }
         } else lookUp();
       } else lookUp();
@@ -60,16 +61,24 @@ module.exports.imp = function (runPath, context) {
 
     const exec = (coptions = {}) => runPath(
       filepath,
-      { import: options, main: false, useContext: execOptions.sharedContext == false ? false : true, ...coptions },
-      execOptions.sharedContext == false ? {} : context,
+      {
+        import: options,
+        main: false,
+        useContext: execOptions.sharedContext == false ? false : !(options.context && options.context == 'new'),
+        ...coptions,
+        as: options.as == 'main' ? context.module.main ? 'main' : 'parent' : options.as == 'parent' ? 'parent' : 'child',
+        fromMain: context.module.main
+      },
+      execOptions.sharedContext == false ? {} :
+        options.context && options.context == 'new' ? {} : context,
     ).context.module.exports;
 
     if (ispkg) {
       exports = getPackage(filename)(context);
-    } else if(foundCache) {
-      
+    } else if (foundCache) {
+
     } else if (type == "coffee") {
-      exports = exec({ });
+      exports = exec({});
     } else if (type == "js") {
       exports = exec({ compile: false });
     } else if (type == "yaml" || type == "json" || type == "text") {
@@ -95,8 +104,8 @@ module.exports.imp = function (runPath, context) {
         }
     }
 
-    if(!ispkg) context.module.imports.push(filepath);
-    if(!ispkg) cachedFiles.push({ filepath, exports });
+    if (!ispkg) context.module.imports.push(filepath);
+    if (!ispkg) cachedFiles.push({ filepath, exports });
 
     return exports;
   };

package/lib/rew/functions/types.js

@@ -15,17 +15,21 @@ function getType(value){
   return typeof value === 'object' ? Array.isArray(value) ? 'array' : typeof value : typeof value;
 }
 
-function typedef(value) {
+function typedef(value, strict = false) {
   return {
+    strict,
     defaultValue: value,
     class: typeof value == 'function' ? value : typeof value === 'object' && value !== null && !Array.isArray(value) ? value.constructor : _defaultConstructors[getType(value)],
     type: getType(value),
     isConstucted: typeof value === 'object' && value !== null && !Array.isArray(value),
-    isEmpty: typeof value == "object" ? !Object.keys(value).length : typeof value == "string" ? value == "" : true
+    isEmpty: typeof value == "object" ? !Object.keys(value).length : typeof value == "string" ? value == "" : typeof value !== "function"
   };
 }
 
 function typeis(obj, typeDef) {
+  // Resolve Type
+  if(typeof typeDef == "function" && typeDef.type) typeDef = typeDef.type;
+
   if (typeDef.isConstucted && typeDef.class && !(obj instanceof typeDef.class)) {
     return false;
   }
@@ -41,7 +45,9 @@ function typeis(obj, typeDef) {
   if(!typeDef.isEmpty) {
     if(typeDef.type == 'object'){
       for (const key in typeDef.defaultValue) {
-        const propTypeDef = typeDef.defaultValue[key];
+        let propTypeDef = typeDef.defaultValue[key];
+        // Resolve type
+        if(typeof propTypeDef == "function" && propTypeDef.type) propTypeDef = propTypeDef.type;
     
         if (typeof propTypeDef === 'object') {
           if (!typeis(obj[key], propTypeDef)) {
@@ -51,8 +57,13 @@ function typeis(obj, typeDef) {
           return false;
         }
       }
+      if(typeDef.strict) {
+        if(Object.keys(obj).some(key => !Object.keys(typeDef.defaultValue).includes(key))) return false;
+      }
     } else if(typeDef.type == 'string'){
       return typeDef.defaultValue == obj;
+    } else if(typeDef.type == 'function'){
+      return typeDef.defaultValue == obj;
     }
   }
 
@@ -70,24 +81,29 @@ function typei(child, parent) {
 function int(str){
   return parseInt(str);
 }
+int.type = typedef(1)
 
 function float(str){
   return parseFloat(str);
 }
+float.type = typedef(1.0)
 
 function num(str){
   return Number(str);
 }
+num.type = typedef(1)
 
 function str(str){
   return str ? str.toString() : "";
 }
+str.type = typedef('')
 
 function bool(value){
   return typeof value == 'string' ? (
     value == 'true' ? true : false
   ) : value !== null && value !== undefined;
 }
+bool.type = typedef(true)
 
 module.exports = {
   typex,

package/lib/rew/html/ui.js

@@ -189,10 +189,20 @@ window.recieveMessage = (data) => {
     } catch (e) {
       log(e.toString());
     }
-  } 
+  } else if(edata.action == 'message') {
+    window.dispatchEvent(new CustomEvent('message', {
+      detail: edata.data
+    }));
+  }
 };
 
 window.addEventListener('load', () => {
-  window.exec(window.execContext);
+  window.exec({
+    ...window.execContext,
+    window,
+    log,
+    send: (data) => sendData({ action: 'message', data  }),
+    onRecieve: (cb) => window.addEventListener('message', (e) => cb(e.detail || {}))
+  });
   log('SETUP::READY');
 });

package/lib/rew/modules/compiler.js

@@ -1,5 +1,8 @@
 const { compile } = require("../../coffeescript/coffeescript");
+const { execOptions } = require("../const/opt");
 const { getFile } = require("./fs");
+const babel = require('@babel/core');
+const babelReact = require('@babel/preset-react');
 
 function tokenizeCoffeeScript(code) {
   const tokens = [];
@@ -11,7 +14,7 @@ function tokenizeCoffeeScript(code) {
 
     if (char === '#') {
       // Comment
-      tokens.push({ type: 'COMMENT', value: char + code.substring(i + 1).split('\n')[0] });
+      tokens.push({ type: 'COMMENT', value: char + code.substring(i + 1).split('\n')[0]+'\n' });
       i = code.indexOf('\n', i);
     } else if (char === '"' || char === "'") {
       // String
@@ -75,7 +78,7 @@ const fnextToken = (i, tokens, type, value) => {
   return tokens.map((t, ind) => { t.ti = ind; return t }).slice(i, tokens.length - 1).map((t, ind) => { t.ri = ind; t.index = ind - i; return t }).find(t => t.type == type && (value ? t.value == value : true));
 }
 
-function compileRewStuff(content) {
+function compileRewStuff(content, options) {
   const tokens = tokenizeCoffeeScript(content);
   let result = '';
 
@@ -85,12 +88,27 @@ function compileRewStuff(content) {
     const token = tokens[i];
     let { nextToken, n } = gnextToken(i, 1, tokens) || {};
 
+    if (token.type === 'IDENTIFIER' && token.value === 'opt') {
+      const { nextToken: nextNextToken } = gnextToken(i, 2, tokens) || {};
+      if(nextNextToken && nextNextToken.value == 'jsxPragma'){
+        const { nextToken: nextLastToken } = gnextToken(i, 5, tokens) || {};
+        execOptions.jsxPragma = nextLastToken.value.slice(1).slice(0, -1);
+      }
+    }
+
+    if (token.type === 'COMMENT' && token.value.slice(1).trim() === '@jsx') {
+      options.jsx = true;
+    }
+
     if (token.type === 'IDENTIFIER' && token.value === 'import') {
       // console.log(nextToken.type);
       let ind = i + n + 2;
 
       let defaultName;
-      if (nextToken.value === '{') {
+      if (nextToken.type === 'STRING') {
+        result += `inc ${nextToken.value}`;
+        i += n;
+      } else if (nextToken.value === '{') {
         const closingBraceToken = fnextToken(ind, tokens, 'OTHER', '}');
         const nameToken = fnextToken(ind, tokens, 'STRING');
         if (closingBraceToken) {
@@ -108,11 +126,23 @@ function compileRewStuff(content) {
           result += `${defaultName} = inc ${nameToken.value}`;
           i = ind + 6;
         }
-      } else {
+      } else if(nextToken) {
         const nameToken = fnextToken(ind, tokens, 'STRING');
         defaultName = nextToken.value;
-        result += `{ default: ${defaultName} } = inc ${nameToken.value}`;
-        i = ind + 2;
+        let { nextToken: nextNextToken, n: n2 } = gnextToken(i + 2, 1, tokens) || {};
+        if(nextNextToken?.type == 'OTHER' && nextNextToken?.value == ','){
+          const closingBraceToken = fnextToken(ind, tokens, 'OTHER', '}');
+          if(closingBraceToken){
+            const exportsTokens = tokens.slice(ind, closingBraceToken.ti);
+            const exports = exportsTokens.filter(t => t.type === 'IDENTIFIER').map(t => t.value).join(', ');
+            result += `{ default: ${defaultName}, ${exports} } = inc ${nameToken?.value || ""}`;
+            i = closingBraceToken.ti + 4;
+          }
+        } else {
+          result += `{ default: ${defaultName} } = inc ${nameToken?.value || ""}`;
+          i = ind + 2;
+        }
+        
       }
 
       const nextLastToken = fnextToken(i, tokens, 'IDENTIFIER');
@@ -154,7 +184,14 @@ function compileRewStuff(content) {
 
 
 const cpl = (module.exports.compile = function (file, options = {}) {
-  return compile(compileRewStuff(file.content), { ...options, filename: file.path, bare: true, inlineMap: true });
+  let c = compile(compileRewStuff(file.content, options), { ...options, filename: file.path, bare: false, inlineMap: false });
+  if(options.jsx) {
+    c = babel.transformSync(c, {
+      presets: [[babelReact, { pragma: execOptions.jsxPragma }]],
+      plugins: []
+    }).code;
+  }
+  return c;
 });
 
 module.exports.compileFile = function (filepath, options = {}) {

package/lib/rew/modules/context.js

@@ -8,17 +8,20 @@ const fsLib = require('../functions/fs');
 const pathLib = require('../functions/path');
 const execLib = require('../functions/exec');
 
+let mainFile = "";
+const isMainFile = filepath => filepath == mainFile;
 module.exports.prepareContext = function (
   custom_context,
   options,
   filepath = "",
   runPath = () => {},
 ) {
+  if(mainFile == "") mainFile = filepath;
   let context = {
     module: {
       exports: null,
       filepath,
-      main: options.main ?? true,
+      main: isMainFile(filepath),
       imports: []
     },
     imports: {
@@ -29,8 +32,8 @@ module.exports.prepareContext = function (
   };
   if (options.useContext) {
     context = {
-      ...context,
       ...custom_context,
+      ...context
     };
   } else {
     context = {
@@ -45,34 +48,43 @@ module.exports.prepareContext = function (
           throw new Error("Module "+package+" not found");
         }
       },
-      opt: {
-        set: (key, value) => execOptions[key] = value,
-        get: (key) => execOptions[key],
-        push: (key, value) => execOptions[key]?.push(value),
-        pop: (key) => execOptions[key]?.pop()
-      },
       ...custom_context,
     };
-    context.imp = imp(runPath, context);
-    context.inc = (package, asserts) => {
-      try{
-        return context.imp(package, asserts);
-      } catch(e) {
-        return context.require(package);
-      }
-    };
-    context.pub = pubFunction(context);
-    context.exports = exportsFunction(context);
   }
-  if (!context.global) context.global = context;
   if (!context.process)
     context.process = {
       argv: process.argv,
-      target: emitter(),
+      target: {
+        on: (event, listener) => process.on(event, listener),
+        off: (event, listener) => process.off(event, listener),
+        emit: (event, code) => process.emit(event, code)
+      },
       env: process.env,
       cwd: () => process.cwd(),
       arch: process.arch
     };
+  
+  context.global = context;
   context.imports.assert = options.import ?? {};
+  context.imp = imp(runPath, context);
+  context.inc = (package, asserts) => {
+    try{
+      if(package.startsWith('node:') || package.startsWith('pkg:')) throw new Error('');
+      return context.imp(package, asserts);
+    } catch(e) {
+      return context.require(package.startsWith('pkg:') ? package.split('pkg:')[1] : package);
+    }
+  };
+  context.pub = pubFunction(context);
+  context.exports = exportsFunction(context);
+
+  if(context.module.main || (options.fromMain == true && options.as == 'main')){
+    context.opt = {
+      set: (key, value) => execOptions[key] = value,
+      get: (key) => execOptions[key],
+      push: (key, value) => execOptions[key]?.push(value),
+      pop: (key) => execOptions[key]?.pop()
+    };
+  } else delete context.opt
   return context;
 };

package/lib/rew/modules/runtime.js

@@ -3,7 +3,11 @@ const { compileFile } = require("./compiler");
 const { prepareContext } = require("./context");
 
 const exec = (module.exports.exec = function (code, context) {
-  return vm.runInNewContext(code, vm.createContext(context));
+  return vm.runInNewContext(code, vm.createContext(context), {
+    filename: context.module.filepath,
+    lineOffset: 0,
+    displayErrors: true
+  });
 });
 
 module.exports.runPath = function runPath(

package/lib/rew/pkgs/modules/ui/classes.js

@@ -161,11 +161,17 @@ module.exports.uiClasses = (context, options, send, recieve, hook, rmHook) => {
   //   }
   // }, false);
 
+  const Transmitter = {
+    send: (data) => send({ action: 'message', data }),
+    recieve: (cb) => recieve((data) => cb(data.data))
+  }
+
   return {
     Widget: RewWidget,
     Text: RewTextWidget,
     WidgetOptions: RemWidgetOptions,
     findElement,
-    StyleSheet: StyleSheet
+    StyleSheet: StyleSheet,
+    Transmitter
   }
 }

package/lib/rew/pkgs/ui.js

@@ -1,7 +1,5 @@
 const path = require("path");
 const { spawn, exec } = require("child_process");
-const WebSocket = require("ws");
-const http = require("http");
 const fs = require("fs");
 const { uiClasses } = require("./modules/ui/classes");
 const { generateRandomID } = require("../functions/id");
@@ -92,9 +90,7 @@ module.exports = (context) => ({
         }
       });
 
-    const p = spawn(BIN_PATH, [runId]);
-
-
+    const p = spawn(options.bin || BIN_PATH, [runId]);
 
     p.on("close", (code) => {
       rl.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makano/rew",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "description": "A simple coffescript runtime",
   "main": "lib/rew/main.js",
   "directories": {
@@ -11,7 +11,9 @@
   },
   "files": [
     "lib/",
+    "cpp/",
     "bin/",
+    "build.sh",
     "README.md"
   ],
   "bin": {
@@ -25,6 +27,9 @@
   "author": "makano",
   "license": "ISC",
   "dependencies": {
+    "@babel/core": "^7.24.6",
+    "@babel/preset-react": "^7.24.6",
+    "babel-plugin-jsx": "^1.2.0",
     "chalk": "^5.3.0",
     "chokidar": "^3.6.0",
     "js-yaml": "^4.1.0",