@makano/rew 1.1.1 → 1.1.5

package/README.md

@@ -1,5 +1,5 @@
 <h3 align="center">
-<img src="https://raw.githubusercontent.com/kevinJ045/rew/main/assets/logo.png" width="100" />
+<img src="https://raw.githubusercontent.com/kevinJ045/rew-docs/main/assets/logo.png" width="100" />
 <br/>
 Rew
 <br/>

package/bin/rew

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 const path = require('path');
 const fs = require('fs');
-const rew_mod = path.resolve(process.cwd(), 'node_modules/@makano/rew');
+const rew_mod = path.resolve(process.cwd(), 'snode_moduless/@makano/rew');
 if(fs.existsSync(rew_mod)){
   require(path.join(rew_mod, 'lib/rew/cli/cli.js'));
 } else {

package/lib/rew/cli/cli.js

@@ -6,8 +6,9 @@ const { hideBin } = require('yargs/helpers');
 const { fork, exec } = 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(
@@ -47,8 +48,6 @@ yargs(hideBin(process.argv))
             data.forEach(file => {
               watchIt(file);
             });
-          } else {
-            process.exit();
           }
         }).send({ filePath, watch: argv.watch });
         if(argv.watch) watchIt(filePath);
@@ -127,9 +126,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/run.js

@@ -1,6 +1,4 @@
-const path = require('path');
 const { run } = require('../main');
-const { watch } = require('fs');
 
 
 function exec(filePath){
@@ -8,13 +6,12 @@ function exec(filePath){
     .context.module.imports;
 }
 
-
-process.on('message', ({ filePath, watch }) => {
+const onmsg = ({ filePath, watch }) => {
   const imports = exec(filePath);
   if(watch){
     process.send(imports);
-    process.exit();
-  } else {
-    process.exit();
   }
-});
+  process.off('message', onmsg);
+}
+
+process.on('message', onmsg);

package/lib/rew/cli/utils.js

@@ -107,7 +107,7 @@ module.exports = {
       const c = jsYaml.load(fs.readFileSync(confPath, { encoding: 'utf-8' }));
       if(c.entry){
         const r = path.resolve(root, c.entry);
-        const mod_path = path.resolve(root, 'node_modules/@makano/rew');
+        const mod_path = path.resolve(root, 'snode_moduless/@makano/rew');
         const mod_path_lib = path.join(mod_path, 'lib/rew/cli');
         if(fs.existsSync(mod_path) && __dirname !== mod_path_lib){
           const mod_path_utilsjs = path.join(mod_path_lib, '../main.js');

package/lib/rew/const/default.js

@@ -5,8 +5,9 @@ const future = require("../functions/future");
 const sleep = require("../functions/sleep");
 const { match } = require("../functions/match");
 const { map } = require("../functions/map");
-const { typex, typeis, typedef, typei } = require("../functions/types");
+const { typex, typeis, typedef, typei, int, float, num, str, bool } = require("../functions/types");
 const { isEmpty, clone, deepClone, merge, uniqueId, compose, curry } = require("../functions/core");
+const { print, input } = require("../functions/stdout");
 
 module.exports = {
   cenum,
@@ -16,11 +17,18 @@ module.exports = {
   sleep,
   match,
   map,
+
   typex,
   typei,
   typeis,
   typedef,
 
+  int,
+  float,
+  num,
+  str,
+  bool,
+
   isEmpty,
   clone,
   deepClone,
@@ -29,7 +37,6 @@ module.exports = {
   compose,
   curry,
 
-  print: function (...arguments) {
-    return console.log(...arguments);
-  },
+  print,
+  input
 };

package/lib/rew/const/opt.js

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

package/lib/rew/functions/core.js

@@ -1,4 +1,5 @@
 
+
 function isEmpty(value) {
   if (Array.isArray(value) || typeof value === 'string') {
     return value.length === 0;

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

@@ -0,0 +1,54 @@
+const fs = require('fs');
+const path = require('path');
+const { execOptions } = require('../const/opt');
+
+
+module.exports = (currentFile) => {
+
+  function gp(filepath){
+    return path.resolve(filepath.startsWith(execOptions.cwdAlias) ? process.cwd() : path.dirname(currentFile), filepath.replaceAll(execOptions.cwdAlias+'/', ''));
+  }
+
+  function read(filepath, options = { encoding: 'utf-8' }){
+    return fs.readFileSync(gp(filepath), options);
+  }
+
+  function write(filepath, content, options){
+    return fs.writeFileSync(gp(filepath), content, options);
+  }
+
+  function exists(filepath, options){
+    return fs.existsSync(gp(filepath));
+  }
+
+  function fstat(filepath, options){
+    return fs.statSync(gp(filepath), options);
+  }
+
+  function rm(filepath, options){
+    return fs.unlinkSync(filepath);
+  }
+
+  function chmod(filepath, mode, options){
+    return fs.chmodSync(gp(filepath), mode);
+  }
+
+  function mkdir(filepath, options){
+    return fs.mkdirSync(gp(filepath), options);
+  }
+
+  function ls(filepath, options){
+    return fs.readdirSync(gp(filepath), options);
+  }
+
+  return {
+    ls,
+    mkdir,
+    chmod,
+    rm,
+    fstat,
+    exists,
+    write,
+    read
+  };
+} 

package/lib/rew/functions/import.js

@@ -5,6 +5,9 @@ const { findPackage, getPackage } = require("../pkgs/pkgs");
 const { existsSync, readFileSync } = require("fs");
 const conf = require("../pkgs/conf");
 const jsYaml = require("js-yaml");
+const { execOptions } = require("../const/opt");
+
+const cachedFiles = [];
 
 const lookUpInOtherApps = (fullPath) => {
   const con = conf({});
@@ -30,26 +33,45 @@ module.exports.imp = function (runPath, context) {
 
     // console.log(typeof runPath);
 
-    if(!ispkg && !existsSync(filepath)){
+    const lookUp = () => {
       const otherPath = lookUpInOtherApps(filename);
       if(!otherPath) throw new Error('Module "'+filename+'" not found');
       else filepath = otherPath;
     }
 
+    const foundCache = cachedFiles.find(f => f.filepath == filepath);
+
+    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) {
+          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];  
+          }
+        } else lookUp();
+      } else lookUp();
+    }
+
+    const exec = (coptions = {}) => runPath(
+      filepath,
+      { import: options, main: false, useContext: execOptions.sharedContext == false ? false : true, ...coptions },
+      execOptions.sharedContext == false ? {} : context,
+    ).context.module.exports;
+
     if (ispkg) {
       exports = getPackage(filename)(context);
+    } else if(foundCache) {
+      
     } else if (type == "coffee") {
-      exports = runPath(
-        filepath,
-        { ...options, useContext: true },
-        context,
-      ).context.module.exports;
+      exports = exec({ });
     } else if (type == "js") {
-      exports = runPath(
-        filepath,
-        { ...options, useContext: true, compile: false },
-        context,
-      ).context.module.exports;
+      exports = exec({ compile: false });
     } else if (type == "yaml" || type == "json" || type == "text") {
       const f = getFile(filepath);
       if (type == "yaml") {
@@ -74,6 +96,7 @@ module.exports.imp = function (runPath, context) {
     }
 
     if(!ispkg) context.module.imports.push(filepath);
+    if(!ispkg) cachedFiles.push({ filepath, exports });
 
     return exports;
   };

package/lib/rew/functions/path.js

@@ -0,0 +1,13 @@
+const path = require('path');
+
+module.exports = (currentFile) => {
+  const e = {};
+  e.basename = (pathname, suffix) => path.basename(pathname, suffix);
+  e.dirname = (pathname) => path.dirname(pathname);
+  e.extname = (pathname) => path.extname(pathname);
+
+  e.pjoin = (...paths) => path.join(...paths);
+  e.presolve = (...paths) => path.resolve(...paths);
+
+  return e;
+}

package/lib/rew/functions/require.js

@@ -0,0 +1,41 @@
+const fs = require('fs');
+const path = require('path');
+
+
+module.exports.customRequire = function customRequire(modulePath, filePath) {
+  const resolvedPath = resolveModulePath(modulePath, filePath);
+  return require(resolvedPath);
+}
+
+function resolveModulePath(modulePath, filePath) {
+  if (modulePath.startsWith('./') || modulePath.startsWith('../') || path.isAbsolute(modulePath)) {
+    return path.resolve(modulePath);
+  }
+
+  const paths = module.constructor._nodeModulePaths(path.dirname(filePath));
+  for (const basePath of paths) {
+    const fullPath = path.join(basePath, modulePath);
+    if (fs.existsSync(fullPath + '.js')) {
+      return fullPath + '.js';
+    }
+    if (fs.existsSync(fullPath + '.json')) {
+      return fullPath + '.json';
+    }
+    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+      const packageJsonPath = path.join(fullPath, 'package.json');
+      if (fs.existsSync(packageJsonPath)) {
+        const main = require(packageJsonPath).main || 'index.js';
+        const mainPath = path.join(fullPath, main);
+        if (fs.existsSync(mainPath)) {
+          return mainPath;
+        }
+      }
+      const indexPath = path.join(fullPath, 'index.js');
+      if (fs.existsSync(indexPath)) {
+        return indexPath;
+      }
+    }
+  }
+
+  throw new Error(`Cannot find module '${modulePath}'`);
+}

package/lib/rew/functions/stdout.js

@@ -0,0 +1,30 @@
+const { execSync, spawnSync } = require('child_process');
+const fs = require('fs');
+
+const print = module.exports.print = function print(...arguments) {
+  return console.log(...arguments);
+};
+
+print.stdout = process.stdout;
+print.stdin = process.stdin;
+
+module.exports.input = function input(prompt) {
+  process.stdout.write(prompt);
+
+  let cmd;
+  let args;
+  if ("null" == "win32") {
+    cmd = 'cmd';
+    args = ['/V:ON', '/C', 'set /p response= && echo !response!'];
+  } else {
+    cmd = 'bash';
+    args = ['-c', 'read response; echo "$response"'];
+  }
+
+  let opts = {
+    stdio: ['inherit', 'pipe'],
+    shell: false,
+  };
+  
+  return spawnSync(cmd, args, opts).stdout.toString().trim();
+}

package/lib/rew/functions/types.js

@@ -67,11 +67,39 @@ function typei(child, parent) {
   return child instanceof parent || child.constructor === parent;
 }
 
+function int(str){
+  return parseInt(str);
+}
+
+function float(str){
+  return parseFloat(str);
+}
+
+function num(str){
+  return Number(str);
+}
+
+function str(str){
+  return str ? str.toString() : "";
+}
+
+function bool(value){
+  return typeof value == 'string' ? (
+    value == 'true' ? true : false
+  ) : value !== null && value !== undefined;
+}
+
 module.exports = {
   typex,
   typei,
   typeis,
-  typedef
+  typedef,
+  
+  int,
+  float,
+  num,
+  str,
+  bool
 }
 
 

package/lib/rew/modules/compiler.js

@@ -1,8 +1,160 @@
 const { compile } = require("../../coffeescript/coffeescript");
 const { getFile } = require("./fs");
 
+function tokenizeCoffeeScript(code) {
+  const tokens = [];
+  let currentToken = '';
+
+  for (let i = 0; i < code.length; i++) {
+    const char = code[i];
+    const nextChar = code[i + 1];
+
+    if (char === '#') {
+      // Comment
+      tokens.push({ type: 'COMMENT', value: char + code.substring(i + 1).split('\n')[0] });
+      i = code.indexOf('\n', i);
+    } else if (char === '"' || char === "'") {
+      // String
+      let string = char;
+      let escaped = false;
+      i++;
+      while (i < code.length && (code[i] !== char || escaped)) {
+        string += code[i];
+        if (code[i] === '\\' && !escaped) {
+          escaped = true;
+        } else {
+          escaped = false;
+        }
+        i++;
+      }
+      string += char; // Include closing quote
+      tokens.push({ type: 'STRING', value: string });
+    } else if (char === '/' && (nextChar === '/' || nextChar === '*')) {
+      // Regular expression
+      let regex = char;
+      i++;
+      while (i < code.length && (code[i] !== '/' || regex.endsWith('\\'))) {
+        regex += code[i];
+        i++;
+      }
+      regex += '/';
+      tokens.push({ type: 'REGEX', value: regex });
+    } else if (/\s/.test(char)) {
+      // Whitespace
+      if(tokens[tokens.length-1]?.type == 'WHITESPACE'
+        && tokens[tokens.length-1].value[0] == char
+      ){
+        tokens[tokens.length-1].value += char;
+      } else {
+        tokens.push({ type: 'WHITESPACE', value: char });
+      }
+    } else if (/[a-zA-Z_$]/.test(char)) {
+      // Identifier
+      let identifier = char;
+      i++;
+      while (i < code.length && /[a-zA-Z0-9_$]/.test(code[i])) {
+        identifier += code[i];
+        i++;
+      }
+      tokens.push({ type: 'IDENTIFIER', value: identifier });
+      i--; // Move back one character to recheck
+    } else {
+      // Other characters
+      tokens.push({ type: 'OTHER', value: char });
+    }
+  }
+
+  return tokens;
+}
+
+const gnextToken = (i, n, tokens) => {
+  return tokens[i + n] ? tokens[i + n].type == 'WHITESPACE' ? gnextToken(i, n + 1, tokens) : { nextToken: tokens[i + n], n } : null;
+}
+
+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) {
+  const tokens = tokenizeCoffeeScript(content);
+  let result = '';
+
+  let hooks = [];
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    let { nextToken, n } = gnextToken(i, 1, tokens) || {};
+
+    if (token.type === 'IDENTIFIER' && token.value === 'import') {
+      // console.log(nextToken.type);
+      let ind = i + n + 2;
+
+      let defaultName;
+      if (nextToken.value === '{') {
+        const closingBraceToken = fnextToken(ind, tokens, 'OTHER', '}');
+        const nameToken = fnextToken(ind, tokens, 'STRING');
+        if (closingBraceToken) {
+          const exportsTokens = tokens.slice(ind, closingBraceToken.ti);
+          const exports = exportsTokens.filter(t => t.type === 'IDENTIFIER').map(t => t.value).join(', ');
+          result += `{ ${exports} } = inc ${nameToken.value}`;
+          i = nameToken.ti;
+        }
+      } else if (nextToken.value === '*') {
+        const asToken = fnextToken(ind, tokens, 'IDENTIFIER', 'as');
+        const nameToken = fnextToken(asToken.ri, tokens, 'STRING');
+        if (asToken) {
+          const nextToken = fnextToken(asToken.ti + 1, tokens, 'IDENTIFIER');
+          defaultName = nextToken.value;
+          result += `${defaultName} = inc ${nameToken.value}`;
+          i = ind + 6;
+        }
+      } else {
+        const nameToken = fnextToken(ind, tokens, 'STRING');
+        defaultName = nextToken.value;
+        result += `{ default: ${defaultName} } = inc ${nameToken.value}`;
+        i = ind + 2;
+      }
+
+      const nextLastToken = fnextToken(i, tokens, 'IDENTIFIER');
+
+      if(nextLastToken?.value == 'assert'){
+        result += ', ';
+        i += 3;
+      }
+
+      continue;
+    }
+
+
+    if (token.type === 'IDENTIFIER' && token.value === 'pub' &&
+      nextToken && nextToken.type === 'IDENTIFIER' &&
+      nextToken.value && nextToken.value !== 'undefined') {
+
+      hooks.push({
+        index: i + 1,
+        value: `"${nextToken.value}", `
+      });
+    }
+
+    result += token.value;
+    if (hooks.length) {
+      hooks.forEach((hook, ind) => {
+        if (i == hook.index) {
+          result += hook.value;
+          hooks.splice(ind, 1);
+        }
+      });
+    }
+  }
+
+  // console.log(result)
+
+  return result;
+}
+
+
 const cpl = (module.exports.compile = function (file, options = {}) {
-  return compile(file.content, options);
+  return compile(compileRewStuff(file.content), { ...options, filename: file.path, bare: true, inlineMap: true });
 });
 
 module.exports.compileFile = function (filepath, options = {}) {

package/lib/rew/modules/context.js

@@ -1,7 +1,12 @@
 const defaultContext = require("../const/default");
+const { execOptions } = require("../const/opt");
 const emitter = require("../functions/emitter");
-const { exportsFunction } = require("../functions/export");
+const { exportsFunction, pubFunction } = require("../functions/export");
 const { imp } = require("../functions/import");
+const { customRequire } = require("../functions/require");
+const fsLib = require('../functions/fs');
+const pathLib = require('../functions/path');
+const execLib = require('../functions/exec');
 
 module.exports.prepareContext = function (
   custom_context,
@@ -12,10 +17,15 @@ module.exports.prepareContext = function (
   let context = {
     module: {
       exports: null,
-      options,
       filepath,
+      main: options.main ?? true,
       imports: []
     },
+    imports: {
+      meta: {},
+      assert: options.import ?? {}
+    },
+    ...fsLib(filepath),
   };
   if (options.useContext) {
     context = {
@@ -26,16 +36,32 @@ module.exports.prepareContext = function (
     context = {
       ...context,
       ...defaultContext,
+      ...pathLib(filepath),
+      ...execLib(filepath),
       require: (package) => {
         try {
-          return require(package);
+          return execOptions.nativeRequire || package.startsWith('node:') ? require(package.startsWith('node:') ? package.split('node:')[1] : package) : customRequire(package, filepath);
         } catch (e) {
-          throw new Error("Module not found");
+          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;
@@ -44,7 +70,9 @@ module.exports.prepareContext = function (
       argv: process.argv,
       target: emitter(),
       env: process.env,
+      cwd: () => process.cwd(),
+      arch: process.arch
     };
-  // console.log(custom_context);
+  context.imports.assert = options.import ?? {};
   return context;
 };

package/lib/rew/pkgs/env.js

@@ -0,0 +1,9 @@
+
+
+module.exports = (context) => ({
+  has: (key) => key in process.env,
+  get: (key) => process.env[key],
+  set: (key, value) => process.env[key] = value,
+  rm: (key) => delete process.env[key],
+  is: (key, value) => process.env[key] == value
+})

package/lib/rew/pkgs/modules/threads/worker.js

@@ -0,0 +1,37 @@
+const { parentPort, workerData } = require('worker_threads');
+const { exec } = require('../../../modules/runtime');
+
+const target = {};
+target.events = [];
+target.on = (e, cb) => {
+  target.events.push({ e, cb });
+}
+target.off = (e) => {
+  target.events = target.events.filter(i => i.e !== e);
+}
+target.emit = (e, data) => {
+  target.events.filter(i => i.e == e).forEach(i => i.cb(data));
+}
+
+parentPort.on('message', (data) => {
+  if (data.type === 'event') {
+    target.emit(data.event, data.data);
+  } else if (data.type === 'start') {
+    (async () => {
+      try {
+        exec(`(${workerData.cb}).call({ process }, context)`, { print: (...a) => console.log(...a), process: {
+          on: (e, cb) => { target.on(e, cb) },
+          off: (e) => { target.off(e) },
+          emit: (e, data) => { parentPort.postMessage({ type: 'event', event: e, data }) },
+          exit: (code) => process.exit(code),
+          finish: (data) => {
+            parentPort.postMessage({ type: 'result', result: data });
+            process.exit(0)
+          }
+        }, context: workerData.context })
+      } catch (e) {
+        parentPort.postMessage({ type: 'error', error: e.message });
+      }
+    })();
+  }
+});

package/lib/rew/pkgs/threads.js

@@ -0,0 +1,71 @@
+const { Worker } = require('worker_threads');
+const emitter = require('../functions/emitter');
+const future = require('../functions/future');
+const { struct } = require('../models/struct');
+const path = require('path');
+
+module.exports = (context) => ({
+  thread: (cb) => {
+    const workers = [];
+
+    const stopWorker = (worker) => {
+      workers.splice(workers.indexOf(worker), 1);
+      worker.terminate()
+    };
+
+    const athread = {
+      stopAll: () => {
+        if (!run) return;
+        workers.forEach(stopWorker);
+      },
+      start: (context) => {
+        let dataResult = future(() => {}), listener = emitter();
+        const worker = new Worker(path.resolve(__dirname, './modules/threads/worker.js'), {
+          workerData: { context, cb: cb.toString() }
+        });
+        workers.push(worker);
+
+        const stop = () => stopWorker(worker);
+
+        worker.on('message', (data) => {
+          if (data.type === 'result') {
+            dataResult.resolve(data.result);
+            stop();
+          } else if (data.type === 'error') {
+            reject(new Error(data.error));
+            stop();
+          } else if (data.type === 'event') {
+            listener.emit(data.event, data.data);
+          }
+        });
+
+        worker.on('error', (error) => {
+          console.log(error);
+          stop();
+        });
+
+        let exiting = false;
+
+        worker.on('exit', (code) => {
+          if(exiting) return;
+          stop();
+          if (code !== 0) {
+            throw new Error(`Worker stopped with exit code ${code}`);
+          }
+        });
+
+        worker.postMessage({ type: 'start' });
+
+        return {
+          on: (e, cb) => listener.on(e, cb),
+          off: (e, cb) => listener.off(e, cb),
+          emit: (e, data) => worker?.postMessage({ type: 'event', event: e, data }),
+          get: () => dataResult.wait(),
+          stop: () => { exiting = true; stop(); }
+        };
+      }
+    };
+
+    return athread;
+  }
+});

package/lib/rew/pkgs/ui.js

@@ -26,7 +26,7 @@ const defaultOptions = {
   onExit: () => process.exit(),
   style: '',
   stylePath: THEME_PATH,
-  exec: () => {},
+  exec: () => { },
   execContext: {}
 };
 
@@ -44,18 +44,22 @@ module.exports = (context) => ({
 
     options.runId = runId;
 
-    if(fs.existsSync(options.stylePath)) options.style = fs.readFileSync(options.stylePath, { encoding: 'utf-8' }) + '\n' + options.style;
+    if (fs.existsSync(options.stylePath)) options.style = fs.readFileSync(options.stylePath, { encoding: 'utf-8' }) + '\n' + options.style;
 
-    options.style = ' */\n'+options.style+'\n/* ';
+    options.style = ' */\n' + options.style + '\n/* ';
 
     const HTML = replaceString(HTML_STRING, options);
     const JS = replaceString(JS_STRING, options);
 
+    /**
+     * Queue for future writes
+     * @type {string[]}
+     * */
     const queue = [];
 
     const send = (data) => {
       const content = fs.readFileSync(tmpFile, { encoding: 'utf-8' });
-      if(content) {
+      if (content) {
         queue.push(data);
       } else {
         fs.writeFileSync(tmpFile, typeof data !== "string" ? JSON.stringify(data) : data);
@@ -77,20 +81,20 @@ module.exports = (context) => ({
       output: process.stdout
     });
 
-    rl.question('', () => {});
+    rl.question('', () => { });
 
     fs.writeFileSync(tmpFile, '');
 
     fs.watch(tmpFile, { encoding: 'utf-8' })
-    .on('change', () => {
-      if(queue.length){
-        send(queue.pop());
-      }
-    });
+      .on('change', () => {
+        if (queue.length) {
+          send(queue.pop());
+        }
+      });
 
     const p = spawn(BIN_PATH, [runId]);
 
-    
+
 
     p.on("close", (code) => {
       rl.close();
@@ -103,12 +107,12 @@ module.exports = (context) => ({
     });
 
     g_emitter.on('recieve', (edata) => {
-      if(edata.action.startsWith('hook:')){
+      if (edata.action.startsWith('hook:')) {
         const hook = hookedSocketListeners[edata.data.rid];
         const type = edata.action.split('hook:')[1];
-        if(hook && hook.type == type) {
+        if (hook && hook.type == type) {
           hookedSocketListeners[edata.data.rid].cb(edata.data.object);
-          if(hook.once) delete hookedSocketListeners[edata.data.rid];
+          if (hook.once) delete hookedSocketListeners[edata.data.rid];
         }
       }
     });
@@ -119,7 +123,7 @@ module.exports = (context) => ({
           const d = data.toString().split("RESPONSE::")[1];
           const jd = JSON.parse(d);
           recieve(jd);
-        } else if(data.toString().trim().endsWith('SETUP::READY')) {
+        } else if (data.toString().trim().endsWith('SETUP::READY')) {
           console.log('READY');
           r(uiClasses(context, options, sendEvent, (cb) => {
             g_emitter.on('recieve', cb);
@@ -128,15 +132,15 @@ module.exports = (context) => ({
           }, (rid) => { // Remove hook
             delete hookedSocketListeners[rid];
           }));
-        } else if(data.toString().endsWith('SETUP::HTML')) {
-          send({action: 'JS2', data: JS, isSetup: true});
-        } else if(data.toString() == 'INIT::READY') {
-          send({action: 'HTML', data: HTML});
+        } else if (data.toString().endsWith('SETUP::HTML')) {
+          send({ action: 'JS2', data: JS, isSetup: true });
+        } else if (data.toString() == 'INIT::READY') {
+          send({ action: 'HTML', data: HTML });
         } else {
           console.log(data.toString());
         }
       });
-  
+
       p.stderr.on("data", (data) => {
         console.error(data.toString());
       });

package/package.json

@@ -1,16 +1,13 @@
 {
   "name": "@makano/rew",
-  "version": "1.1.1",
+  "version": "1.1.5",
   "description": "A simple coffescript runtime",
   "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"
+    "test": "node test/test.js"
   },
   "files": [
     "lib/",
@@ -32,7 +29,6 @@
     "chokidar": "^3.6.0",
     "js-yaml": "^4.1.0",
     "vm": "^0.1.0",
-    "ws": "^8.17.0",
     "yargs": "^17.7.2"
   },
   "devDependencies": {