@makano/rew 1.1.2 → 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,11 +3,12 @@
 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 } = require('fs');
+const { existsSync, readFileSync, writeFileSync, mkdirSync } = require('fs');
 const { log } = require('./log');
+const { compileFile, compile } = require('../modules/compiler');
 
 yargs(hideBin(process.argv))
   .command(
@@ -97,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', {
@@ -125,9 +137,69 @@ yargs(hideBin(process.argv))
       .positional('file', {
         describe: 'File to build',
         type: 'string',
+      })
+      .option('output', {
+        alias: 'o',
+        describe: 'Output directory',
+        type: 'string',
       });
   }, (argv) => {
-    console.log(`Building file: ${argv.file}`);
+
+    function readFile(filePath) {
+      return readFileSync(filePath, { encoding: 'utf-8' });
+    }
+
+    function extractImports(content) {
+      const importRegex = /(\w+)\s*=\s*imp\s*['"](.+?)['"]/g;
+      const imports = [];
+      let match;
+      while ((match = importRegex.exec(content)) !== null) {
+        imports.push({ variable: match[1], url: match[2] });
+      }
+      return imports;
+    }
+
+    function writeCompiledFile(filePath, compiledCode) {
+      const dirName = outputDir ? outputDir : path.dirname(filePath);
+      if(!existsSync(dirName)) mkdirSync(dirName, { recursive: true });
+      const baseName = path.basename(filePath, path.extname(filePath));
+      const newFilePath = path.join(dirName, `${baseName}.js`);
+      writeFileSync(newFilePath, compiledCode, { encoding: 'utf-8' });
+      log(`Compiled: ${newFilePath}`);
+    }
+
+    function processFile(filePath, importsArray) {
+      const content = readFile(filePath);
+      const imports = extractImports(content);
+  
+      imports.forEach(importStatement => {
+        const importedFilePath = path.resolve(path.dirname(filePath), importStatement.url);
+        if (!importsArray.some(importObj => importObj.url === importStatement.url)) {
+          
+          if(existsSync(importedFilePath)){
+            importsArray.push(importStatement);
+            processFile(importedFilePath, importsArray);
+          } else if(existsSync(importedFilePath+'.coffee')){
+            importsArray.push(importStatement);
+            processFile(importedFilePath+'.coffee', importsArray);
+          } else if(existsSync(importedFilePath+'.js')){
+            importsArray.push(importStatement);
+            processFile(importedFilePath+'.js', importsArray);
+          }
+
+        }
+      });
+
+      const compiled = compile({ content }, {});
+      writeCompiledFile(filePath, compiled);
+    }
+
+    const filePath = path.resolve(process.cwd(), argv.file);
+    const importsArray = [];
+    const outputDir = argv.output ? path.resolve(process.cwd(), argv.output) : null;
+    log('Start compile at', outputDir || 'default path');
+    processFile(filePath, importsArray);
+    log('Compiled', importsArray.length + 1, 'files.', ':end');
   })
   .help()
   .argv;

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/exec.js

@@ -0,0 +1,27 @@
+const shell = require('child_process');
+
+
+module.exports = (currentFile) => {
+
+  function exec(command, options){
+    return shell.execSync(command, { stdio: options?.output == false ? null : 'inherit' });
+  }
+
+  exec.background = function execAsync(command, options, callback){
+    if(typeof options == "function" && !callback){
+      callback = options;
+      options = {};
+    }
+    if(!options) options = {};
+    if(!callback) callback = () => {};
+    return shell.exec(command, {
+      ...options,
+    }, callback);
+  }
+
+  function spawn(command, options){
+    return shell.spawn(command, options);
+  }
+
+  return { exec, spawn };
+}

package/lib/rew/functions/export.js

@@ -1,9 +1,27 @@
+
+function exportsThe(item, name, context){
+  if (name) {
+    if(!context.module.exports) context.module.exports = {};
+    context.module.exports[name] = item;
+  } else {
+    if(context.module.exports) context.module.exports.default = item;
+    else context.module.exports = item;
+  }
+}
+
+module.exports.pubFunction = function (context) {
+  return function (name, item) {
+    if(name && !item){
+      item = name;
+      name = null;
+    }
+    exportsThe(item, name, context);
+  };
+};
+
 module.exports.exportsFunction = function (context) {
   return function (item, name) {
-    if (name) {
-      context.module.exports[name] = item;
-    } else {
-      context.module.exports = item;
-    }
+    exportsThe(item, name, context);
   };
 };
+

package/lib/rew/functions/fs.js

@@ -13,12 +13,16 @@ 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);
   }
 
   function exists(filepath, options){
-    return fs.existsSync(filepath);
+    return fs.existsSync(gp(filepath));
   }
 
   function fstat(filepath, options){
@@ -49,6 +53,7 @@ module.exports = (currentFile) => {
     fstat,
     exists,
     write,
-    read
+    read,
+    realpath
   };
 }