@makano/rew 1.1.1 → 1.1.15

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

@@ -47,8 +47,6 @@ yargs(hideBin(process.argv))
             data.forEach(file => {
               watchIt(file);
             });
-          } else {
-            process.exit();
           }
         }).send({ filePath, watch: argv.watch });
         if(argv.watch) watchIt(filePath);

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

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

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,
+      { ...options, 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/require.js

@@ -0,0 +1,45 @@
+const fs = require('fs');
+const path = require('path');
+
+
+module.exports.customRequire = function customRequire(modulePath, filePath) {
+  try{
+    return require(modulePath)
+  } catch(e){
+    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/modules/context.js

@@ -1,7 +1,10 @@
 const defaultContext = require("../const/default");
+const { execOptions } = require("../const/opt");
 const emitter = require("../functions/emitter");
 const { exportsFunction } = require("../functions/export");
 const { imp } = require("../functions/import");
+const { customRequire } = require("../functions/require");
+
 
 module.exports.prepareContext = function (
   custom_context,
@@ -16,6 +19,12 @@ module.exports.prepareContext = function (
       filepath,
       imports: []
     },
+    opt: {
+      set: (key, value) => execOptions[key] = value,
+      get: (key) => execOptions[key],
+      push: (key, value) => execOptions[key]?.push(value),
+      pop: (key) => execOptions[key]?.pop()
+    }
   };
   if (options.useContext) {
     context = {
@@ -28,9 +37,9 @@ module.exports.prepareContext = function (
       ...defaultContext,
       require: (package) => {
         try {
-          return require(package);
+          return execOptions.nativeRequire ? require(package) : customRequire(package, filepath);
         } catch (e) {
-          throw new Error("Module not found");
+          throw new Error("Module "+package+" not found");
         }
       },
       ...custom_context,
@@ -44,6 +53,8 @@ module.exports.prepareContext = function (
       argv: process.argv,
       target: emitter(),
       env: process.env,
+      cwd: () => process.cwd(),
+      arch: process.arch
     };
   // console.log(custom_context);
   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) => { 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,67 @@
+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();
+        });
+
+        worker.on('exit', (code) => {
+          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()
+        };
+      }
+    };
+
+    return athread;
+  }
+});

package/package.json

@@ -1,16 +1,13 @@
 {
   "name": "@makano/rew",
-  "version": "1.1.1",
+  "version": "1.1.15",
   "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": {