@makano/rew 1.0.1

package/lib/rew/pkgs/modules/data/bintree.js

@@ -0,0 +1,66 @@
+class TreeNode {
+  constructor(value) {
+    this.value = value;
+    this.left = null;
+    this.right = null;
+  }
+}
+
+class BinaryTree {
+  constructor() {
+    this.root = null;
+  }
+
+  insert(value) {
+    const newNode = new TreeNode(value);
+    if (!this.root) {
+      this.root = newNode;
+      return;
+    }
+
+    const insertNode = (node) => {
+      if (value < node.value) {
+        if (!node.left) {
+          node.left = newNode;
+        } else {
+          insertNode(node.left);
+        }
+      } else {
+        if (!node.right) {
+          node.right = newNode;
+        } else {
+          insertNode(node.right);
+        }
+      }
+    };
+
+    insertNode(this.root);
+  }
+
+  find(value) {
+    const findNode = (node) => {
+      if (!node) return null;
+      if (node.value === value) return node;
+      if (value < node.value) return findNode(node.left);
+      return findNode(node.right);
+    };
+
+    return findNode(this.root);
+  }
+
+  toArray() {
+    const elements = [];
+    const traverse = (node) => {
+      if (!node) return;
+      traverse(node.left);
+      elements.push(node.value);
+      traverse(node.right);
+    };
+    traverse(this.root);
+    return elements;
+  }
+}
+
+BinaryTree.Node = TreeNode;
+
+module.exports = { BinaryTree };

package/lib/rew/pkgs/modules/data/doublylinked.js

@@ -0,0 +1,100 @@
+class DoublyNode {
+  constructor(value) {
+    this.value = value;
+    this.next = null;
+    this.prev = null;
+  }
+}
+
+class DoublyLinkedList {
+  constructor() {
+    this.head = null;
+    this.tail = null;
+    this.length = 0;
+  }
+
+  append(value) {
+    const newNode = new DoublyNode(value);
+    if (!this.head) {
+      this.head = newNode;
+      this.tail = newNode;
+    } else {
+      this.tail.next = newNode;
+      newNode.prev = this.tail;
+      this.tail = newNode;
+    }
+    this.length++;
+  }
+
+  prepend(value) {
+    const newNode = new DoublyNode(value);
+    if (!this.head) {
+      this.head = newNode;
+      this.tail = newNode;
+    } else {
+      newNode.next = this.head;
+      this.head.prev = newNode;
+      this.head = newNode;
+    }
+    this.length++;
+  }
+
+  find(value) {
+    let current = this.head;
+    while (current) {
+      if (current.value === value) {
+        return current;
+      }
+      current = current.next;
+    }
+    return null;
+  }
+
+  delete(value) {
+    if (!this.head) {
+      return null;
+    }
+
+    if (this.head.value === value) {
+      this.head = this.head.next;
+      if (this.head) {
+        this.head.prev = null;
+      } else {
+        this.tail = null;
+      }
+      this.length--;
+      return;
+    }
+
+    let current = this.head;
+    while (current) {
+      if (current.value === value) {
+        if (current.next) {
+          current.next.prev = current.prev;
+        } else {
+          this.tail = current.prev;
+        }
+        if (current.prev) {
+          current.prev.next = current.next;
+        }
+        this.length--;
+        return;
+      }
+      current = current.next;
+    }
+  }
+
+  toArray() {
+    const elements = [];
+    let current = this.head;
+    while (current) {
+      elements.push(current.value);
+      current = current.next;
+    }
+    return elements;
+  }
+}
+
+DoublyLinkedList.Node = DoublyNode;
+
+module.exports = { DoublyLinkedList };

package/lib/rew/pkgs/modules/data/linkedList.js

@@ -0,0 +1,88 @@
+class Node {
+  constructor(value) {
+    this.value = value;
+    this.next = null;
+  }
+}
+
+class LinkedList {
+  constructor() {
+    this.head = null;
+    this.tail = null;
+    this.length = 0;
+  }
+
+  append(value) {
+    const newNode = new Node(value);
+    if (!this.head) {
+      this.head = newNode;
+      this.tail = newNode;
+    } else {
+      this.tail.next = newNode;
+      this.tail = newNode;
+    }
+    this.length++;
+  }
+
+  prepend(value) {
+    const newNode = new Node(value);
+    if (!this.head) {
+      this.head = newNode;
+      this.tail = newNode;
+    } else {
+      newNode.next = this.head;
+      this.head = newNode;
+    }
+    this.length++;
+  }
+
+  find(value) {
+    let current = this.head;
+    while (current) {
+      if (current.value === value) {
+        return current;
+      }
+      current = current.next;
+    }
+    return null;
+  }
+
+  delete(value) {
+    if (!this.head) {
+      return null;
+    }
+
+    if (this.head.value === value) {
+      this.head = this.head.next;
+      this.length--;
+      return;
+    }
+
+    let current = this.head;
+    while (current.next) {
+      if (current.next.value === value) {
+        current.next = current.next.next;
+        if (current.next === null) {
+          this.tail = current;
+        }
+        this.length--;
+        return;
+      }
+      current = current.next;
+    }
+  }
+
+  toArray() {
+    const elements = [];
+    let current = this.head;
+    while (current) {
+      elements.push(current.value);
+      current = current.next;
+    }
+    return elements;
+  }
+}
+
+LinkedList.Node = Node;
+
+module.exports = { LinkedList };

package/lib/rew/pkgs/modules/data/queue.js

@@ -0,0 +1,28 @@
+class Queue {
+  constructor() {
+    this.items = [];
+  }
+
+  enqueue(item) {
+    this.items.push(item);
+  }
+
+  dequeue() {
+    return this.items.shift();
+  }
+
+  isEmpty() {
+    return this.items.length === 0;
+  }
+
+  peek() {
+    return this.items[0];
+  }
+
+  toArray() {
+    return this.items.slice();
+  }
+}
+
+
+module.exports = { Queue };

package/lib/rew/pkgs/modules/data/stack.js

@@ -0,0 +1,27 @@
+class Stack {
+  constructor() {
+    this.items = [];
+  }
+
+  push(item) {
+    this.items.push(item);
+  }
+
+  pop() {
+    return this.items.pop();
+  }
+
+  isEmpty() {
+    return this.items.length === 0;
+  }
+
+  peek() {
+    return this.items[this.items.length - 1];
+  }
+
+  toArray() {
+    return this.items.slice();
+  }
+}
+
+module.exports = { Stack };

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

@@ -0,0 +1,171 @@
+const emitter = require("../../../functions/emitter");
+const { struct } = require("../../../models/struct");
+const { generateRandomID } = require("../../../functions/id");
+
+module.exports.uiClasses = (context, options, svr, send, hook, rmHook) => {
+  const _sanitizeOptions = (options) => {
+    return {
+      ...options,
+      children: options.children.map(i => i.options)
+    }
+  }
+  const RemWidgetOptions = struct({
+    element: 'div',
+    class: '',
+    attr: {},
+    id: '',
+    data: {
+      text: ''
+    },
+    children: [],
+    uuid: '',
+    parent: '!any',
+    style: {}
+  });
+
+  const CreatedElements = [];
+
+  class RewWidget {
+    _emitter = emitter();
+    on(event, callback){
+      const hookID = this.uuid+'_'+generateRandomID(4);
+      this._emitter.on(event, callback, { hookID });
+      hook(hookID, 'event_'+event, (data) => {
+        this.emit(event, data);
+      }, false);
+      send(JSON.stringify({ action: 'eventListen', data: { uuid: this.uuid, event, hookID } }))
+      return this;
+    }
+    off(event, callback){
+      this._emitter.off(event, callback, (e) => rmHook(e.hookID));
+      return this;
+    }
+    emit(event, callback){
+      this._emitter.emit(event, callback);
+      return this;
+    }
+
+    options = RemWidgetOptions();
+    constructor(options = RemWidgetOptions()){
+      const config = RemWidgetOptions(options);
+      config.uuid = generateRandomID();
+      this.options = config;
+      this.options.children.forEach(child => child.parent = this);
+      this.init();
+      CreatedElements.push(this);
+    }
+
+    init(){
+      send(JSON.stringify({ action: 'createElement', data: _sanitizeOptions(this.options) }))
+    }
+
+    parent = null;
+
+    get uuid(){
+      return this.options.uuid;
+    }
+
+    get id(){
+      return this.options.id;
+    }
+
+    get children(){
+      return this.options.children;
+    }
+
+    find(id, recursive = true){
+      let childFound = this.children.find(e => e.id == id) || this.children.find(e => e.uuid == id);
+      if(childFound) return childFound;
+      else if(!recursive) return null;
+      for(let child of this.children){
+        let subchild = child.find(id);
+        if(subchild) {
+          return subchild;
+        }
+      }
+    }
+
+    update(){
+      send(JSON.stringify({ action: 'updateElement', data: _sanitizeOptions(this.options) }));
+      return this;
+    }
+
+    text(text){
+      this.options.data.text = text;
+      return this.update();
+    }
+
+    data(key, value){
+      this.options.data[key] = value;
+      return this.update(); 
+    }
+
+    attr(attr){
+      this.options.attr = attr;
+      return this.update();
+    }
+
+    style(style){
+      this.options.style = style;
+      return this.update();
+    }
+
+    add(child){
+      this.options.children.push(child);
+      return this.update();
+    }
+
+    remove(childId, recursive = true){
+      const child = typeof childId == "string" ? this.find(childId, recursive) : childId;
+      if(!child) return this;
+      if(recursive && child.parent !== this){
+        child.parent.remove(child);
+      } else {
+        this.options.children.splice(this.options.children.indexOf(child), 1);
+        this.update();
+      }
+      return this;
+    }
+
+  }
+
+  class RewTextWidget extends RewWidget {
+    constructor(text = '', options = RemWidgetOptions({})){
+      super({
+        ...options,
+        data: { ...(options.data), text }
+      });
+    }
+  }
+
+  class StyleSheet {
+    constructor(css = ''){
+      send(JSON.stringify({ action: 'addStyleSheet', data: css }));
+    }
+  }
+
+  function findElement(id){
+    return new Promise((r) => {
+      const rid = generateRandomID();
+      hook(rid, 'findElement', (data) => {
+        r(CreatedElements.find(e => e.uuid == data.uuid) || data);
+      });
+      send(JSON.stringify({ action: 'findElement', data: { id, rid } }));
+    });
+  }
+
+  // hook('event_trigger', 'eventTrigger', (data) => {
+  //   const el = CreatedElements.find(e => e.uuid = data.uuid);
+  //   if(el){
+  //     el.emit(data.event, data.data);
+  //   }
+  // }, false);
+
+  return {
+    Widget: RewWidget,
+    Text: RewTextWidget,
+    WidgetOptions: RemWidgetOptions,
+    findElement,
+    StyleSheet: StyleSheet
+  }
+}

package/lib/rew/pkgs/pkgs.js

@@ -0,0 +1,13 @@
+const path = require("path");
+const fs = require("fs");
+
+
+module.exports = {
+  findPackage(pkg) {
+    if(pkg == 'pkgs') return false;
+    return fs.existsSync(path.resolve(__dirname, './'+pkg+'.js'));
+  },
+  getPackage(pkg){
+    return require('./'+pkg);
+  }
+};

package/lib/rew/pkgs/ui.js

@@ -0,0 +1,108 @@
+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");
+const { THEME_PATH } = require("../const/files");
+
+
+const BIN_PATH = path.resolve(__dirname, "../../bin/ui");
+const HTML_STRING = fs.readFileSync(
+  path.resolve(__dirname, "../html/ui.html"),
+  { encoding: "utf-8" },
+);
+
+const defaultOptions = {
+  port: 14473,
+  title: "Title",
+  onExit: () => process.exit(),
+  style: '',
+  stylePath: THEME_PATH,
+  exec: () => {},
+  execContext: {}
+};
+
+module.exports = (context) => ({
+  start: (o = {}) => {
+    const options = {
+      ...defaultOptions,
+      ...o
+    };
+
+    const hookedSocketListeners = {};
+
+    const runId = generateRandomID();
+
+    options.runId = runId;
+
+    if(fs.existsSync(options.stylePath)) options.style = fs.readFileSync(options.stylePath, { encoding: 'utf-8' }) + '\n' + options.style;
+
+    options.style = ' */\n'+options.style+'\n/* ';
+
+    const svr = http.createServer((req, res) => {
+      res.write(
+        HTML_STRING
+          .replace(/\$OPTIONS\(([^)]+)\)/g, (_, n) => n.startsWith('json.') ? JSON.stringify(options[n.split('json.')[1]] || '{}') : options[n] || _)
+      );
+      res.end();
+    });
+
+    const wss = new WebSocket.Server({ server: svr });
+    const sockets = [];
+
+    wss.on("connection", (ws) => {
+      ws.send(JSON.stringify({ action: "init", data: options }));
+      sockets.push(ws);
+      ws.on('message', (event) => {
+        const edata = JSON.parse(event.toString());
+        if(edata.action.startsWith('hook:')){
+          const hook = hookedSocketListeners[edata.data.rid];
+          const type = edata.action.split('hook:')[1];
+          if(hook && hook.type == type) {
+            hookedSocketListeners[edata.data.rid].cb(edata.data.object);
+            if(hook.once) delete hookedSocketListeners[edata.data.rid];
+          }
+        }
+      });
+    });
+
+    svr.listen(options.port);
+
+    const url = new URL(`http://localhost:${options.port}`);
+
+    const p = spawn(BIN_PATH, [url.toString(), runId]);
+
+    p.on("close", (code) => {
+      options.onExit(code);
+    });
+
+    process.on("beforeExit", () => p.kill());
+
+    // p.on('message', console.log);
+    // p.on('error', console.log);
+    // exec(BIN_PATH+' '+'http://localhost:' + port, console.log)
+    return new Promise((r) => {
+      p.stdout.on("data", (data) => {
+        if (data.toString().trim() == "INIT::READY") {
+          r(
+            uiClasses(context, options, svr, (message, cb) => { // Send message
+              sockets.forEach((socket) => socket.send(message, cb));
+            }, (rid, type, cb, once = true) => { // Add hook
+              hookedSocketListeners[rid] = { type, cb, once };
+            }, (rid) => { // Remove hook
+              delete hookedSocketListeners[rid];
+            }),
+          );
+        } else {
+          console.log(data.toString());
+        }
+      });
+
+      p.stderr.on("data", (data) => {
+        console.error(data.toString());
+      });
+    });
+  },
+});

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@makano/rew",
+  "version": "1.0.01",
+  "description": "",
+  "main": "lib/rew/main.js",
+  "directories": {
+    "lib": "lib"
+  },
+  "scripts": {
+    "test": "node test/test.js",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs"
+  },
+  "files": [
+    "lib/",
+    "bin/"
+  ],
+  "bin": {
+    "rew": "bin/rew"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kevinj045/rew.git"
+  },
+  "keywords": [],
+  "author": "makano",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "chokidar": "^3.6.0",
+    "js-yaml": "^4.1.0",
+    "vm": "^0.1.0",
+    "ws": "^8.17.0",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "pkg": "^5.8.1",
+    "vitepress": "^1.2.2"
+  }
+}