@makano/rew 1.1.56 → 1.1.72

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

@@ -82,6 +82,7 @@ module.exports = {
       //   }
       // });
       log('Done.', ':end');
+      rl.close();
     }
     if (!fs.existsSync(projectPath)) {
       rl.question(logget('Package Name: '), (pkg) => {

package/lib/rew/const/opt.js

@@ -2,7 +2,9 @@ const execOptions = {
   sharedContext: true,
   resolveExtensions: [{ext: '.js', options: { type: 'js' }}, '.coffee'],
   nativeRequire: false,
-  cwdAlias: '$'
+  cwdAlias: '$',
+  jsxPragma: 'createElement',
+  jsx: false
 }
 
 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/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(execOptions.jsx || 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/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

@@ -96,17 +96,20 @@ module.exports.uiClasses = (context, options, send, recieve, hook, rmHook) => {
     }
 
     data(key, value){
+      if(!value) return this.options.data[key];
       this.options.data[key] = value;
       return this.update(); 
     }
 
-    attr(attr){
-      this.options.attr = attr;
+    attr(attr, reset = false){
+      if(reset) this.options.attr = attr;
+      else this.options.attr = { ...this.options.attr, ...attr };
       return this.update();
     }
 
-    style(style){
-      this.options.style = style;
+    style(style, reset = false){
+      if(reset) this.options.style = style;
+      else this.options.style = { ...this.options.style, ...style };
       return this.update();
     }
 
@@ -161,11 +164,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/meson.build

@@ -0,0 +1,13 @@
+project('rew', 'cpp',
+  version : '0.1',
+  default_options : ['warning_level=3', 'cpp_std=c++14'])
+
+gtk3 = dependency('gtk+-3.0', method : 'pkg-config')
+webkit2gtk = dependency('webkit2gtk-4.0', method : 'pkg-config')
+libwebsockets = dependency('libwebsockets', method : 'pkg-config')
+jsoncpp = dependency('jsoncpp', method : 'pkg-config')
+
+executable('rew',
+           'cpp/ui.cpp',
+           install : true,
+           dependencies : [gtk3, webkit2gtk, libwebsockets, jsoncpp])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makano/rew",
-  "version": "1.1.56",
+  "version": "1.1.72",
   "description": "A simple coffescript runtime",
   "main": "lib/rew/main.js",
   "directories": {
@@ -11,7 +11,10 @@
   },
   "files": [
     "lib/",
+    "cpp/",
     "bin/",
+    "meson.build",
+    "build.sh",
     "README.md"
   ],
   "bin": {
@@ -25,6 +28,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",