@makano/rew 1.1.2 → 1.1.6

package/lib/rew/functions/import.js

@@ -14,17 +14,18 @@ const lookUpInOtherApps = (fullPath) => {
   const name = fullPath.indexOf('/') ? fullPath.split('/')[0] : fullPath;
   let dpath = fullPath.indexOf('/') ? fullPath.split('/')[1] : '';
   let ppath = path.join(con.CONFIG_PATH, name, 'app');
-  if(!existsSync(ppath)) return null;
-  if(!dpath){
+  if (!existsSync(ppath)) return null;
+  if (!dpath) {
     dpath = jsYaml.load(readFileSync(path.join(ppath, 'app.yaml'), 'utf-8')).entry;
   }
   ppath = path.join(ppath, dpath);
-  if(existsSync(ppath)) return ppath;
+  if (existsSync(ppath)) return ppath;
   else return null;
 }
 
 module.exports.imp = function (runPath, context) {
   return function (filename, options = {}) {
+    if (!options) options = {};
     let type = options.type || "coffee";
     let exports,
       ispkg = findPackage(filename);
@@ -35,24 +36,24 @@ module.exports.imp = function (runPath, context) {
 
     const lookUp = () => {
       const otherPath = lookUpInOtherApps(filename);
-      if(!otherPath) throw new Error('Module "'+filename+'" not found');
+      if (!otherPath) throw new Error('Module "' + filename + '" not found');
       else filepath = otherPath;
     }
 
     const foundCache = cachedFiles.find(f => f.filepath == filepath);
 
-    if(!ispkg && foundCache){
+    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) {
+    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];  
+          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();
@@ -60,16 +61,24 @@ module.exports.imp = function (runPath, context) {
 
     const exec = (coptions = {}) => runPath(
       filepath,
-      { ...options, useContext: execOptions.sharedContext == false ? false : true, ...coptions },
-      execOptions.sharedContext == false ? {} : context,
+      {
+        import: options,
+        main: false,
+        useContext: execOptions.sharedContext == false ? false : !(options.context && options.context == 'new'),
+        ...coptions,
+        as: options.as == 'main' ? context.module.main ? 'main' : 'parent' : options.as == 'parent' ? 'parent' : 'child',
+        fromMain: context.module.main
+      },
+      execOptions.sharedContext == false ? {} :
+        options.context && options.context == 'new' ? {} : context,
     ).context.module.exports;
 
     if (ispkg) {
       exports = getPackage(filename)(context);
-    } else if(foundCache) {
-      
+    } else if (foundCache) {
+
     } else if (type == "coffee") {
-      exports = exec({ });
+      exports = exec({});
     } else if (type == "js") {
       exports = exec({ compile: false });
     } else if (type == "yaml" || type == "json" || type == "text") {
@@ -95,8 +104,8 @@ module.exports.imp = function (runPath, context) {
         }
     }
 
-    if(!ispkg) context.module.imports.push(filepath);
-    if(!ispkg) cachedFiles.push({ filepath, exports });
+    if (!ispkg) context.module.imports.push(filepath);
+    if (!ispkg) cachedFiles.push({ filepath, exports });
 
     return exports;
   };

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,8 +1,197 @@
 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 = [];
+  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]+'\n' });
+      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, options) {
+  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 === '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.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) {
+          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 if(nextToken) {
+        const nameToken = fnextToken(ind, tokens, 'STRING');
+        defaultName = nextToken.value;
+        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');
+
+      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);
+  let c = compile(compileRewStuff(file.content, options), { ...options, filename: file.path, bare: false, inlineMap: false });
+  if(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/context.js

@@ -1,37 +1,46 @@
 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');
 
+let mainFile = "";
+const isMainFile = filepath => filepath == mainFile;
 module.exports.prepareContext = function (
   custom_context,
   options,
   filepath = "",
   runPath = () => {},
 ) {
+  if(mainFile == "") mainFile = filepath;
   let context = {
     module: {
       exports: null,
-      options,
       filepath,
+      main: isMainFile(filepath),
       imports: []
     },
-    ...fsLib(filepath)
+    imports: {
+      meta: {},
+      assert: options.import ?? {}
+    },
+    ...fsLib(filepath),
   };
   if (options.useContext) {
     context = {
-      ...context,
       ...custom_context,
+      ...context
     };
   } else {
     context = {
       ...context,
       ...defaultContext,
       ...pathLib(filepath),
+      ...execLib(filepath),
       require: (package) => {
         try {
           return execOptions.nativeRequire || package.startsWith('node:') ? require(package.startsWith('node:') ? package.split('node:')[1] : package) : customRequire(package, filepath);
@@ -39,26 +48,43 @@ module.exports.prepareContext = function (
           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.exports = exportsFunction(context);
   }
-  if (!context.global) context.global = context;
   if (!context.process)
     context.process = {
       argv: process.argv,
-      target: emitter(),
+      target: {
+        on: (event, listener) => process.on(event, listener),
+        off: (event, listener) => process.off(event, listener),
+        emit: (event, code) => process.emit(event, code)
+      },
       env: process.env,
       cwd: () => process.cwd(),
       arch: process.arch
     };
-  // console.log(custom_context);
+  
+  context.global = context;
+  context.imports.assert = options.import ?? {};
+  context.imp = imp(runPath, context);
+  context.inc = (package, asserts) => {
+    try{
+      if(package.startsWith('node:') || package.startsWith('pkg:')) throw new Error('');
+      return context.imp(package, asserts);
+    } catch(e) {
+      return context.require(package.startsWith('pkg:') ? package.split('pkg:')[1] : package);
+    }
+  };
+  context.pub = pubFunction(context);
+  context.exports = exportsFunction(context);
+
+  if(context.module.main || (options.fromMain == true && options.as == 'main')){
+    context.opt = {
+      set: (key, value) => execOptions[key] = value,
+      get: (key) => execOptions[key],
+      push: (key, value) => execOptions[key]?.push(value),
+      pop: (key) => execOptions[key]?.pop()
+    };
+  } else delete context.opt
   return context;
 };

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/threads/worker.js

@@ -22,7 +22,7 @@ parentPort.on('message', (data) => {
         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 }) },
+          emit: (e, data) => { parentPort.postMessage({ type: 'event', event: e, data }) },
           exit: (code) => process.exit(code),
           finish: (data) => {
             parentPort.postMessage({ type: 'result', result: data });

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

@@ -161,11 +161,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/threads.js

@@ -44,7 +44,10 @@ module.exports = (context) => ({
           stop();
         });
 
+        let exiting = false;
+
         worker.on('exit', (code) => {
+          if(exiting) return;
           stop();
           if (code !== 0) {
             throw new Error(`Worker stopped with exit code ${code}`);
@@ -57,7 +60,8 @@ module.exports = (context) => ({
           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()
+          get: () => dataResult.wait(),
+          stop: () => { exiting = true; stop(); }
         };
       }
     };

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");
@@ -26,7 +24,7 @@ const defaultOptions = {
   onExit: () => process.exit(),
   style: '',
   stylePath: THEME_PATH,
-  exec: () => {},
+  exec: () => { },
   execContext: {}
 };
 
@@ -44,18 +42,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 +79,18 @@ 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());
-      }
-    });
-
-    const p = spawn(BIN_PATH, [runId]);
+      .on('change', () => {
+        if (queue.length) {
+          send(queue.pop());
+        }
+      });
 
-    
+    const p = spawn(options.bin || BIN_PATH, [runId]);
 
     p.on("close", (code) => {
       rl.close();
@@ -103,12 +103,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 +119,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 +128,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());
       });