@makano/rew 1.1.73 → 1.2.0

package/lib/rew/main.js

@@ -1,17 +1,17 @@
-const { compileFile } = require("./modules/compiler");
-const { exec, runPath } = require("./modules/runtime");
-const fs = require("fs");
-const { imp } = require("./functions/import");
-const { FILES } = require("./const/files");
+const { compileFile } = require('./modules/compiler');
+const { exec, runPath } = require('./modules/runtime');
+const fs = require('fs');
+const { imp } = require('./functions/import');
+const { FILES } = require('./const/files');
 
 module.exports.run = function (filepath, options = {}, custom_context = {}) {
-  FILES.forEach(file => {
-    if(fs.existsSync(file.path)) return;
-    if(file.content){
-      fs.writeFileSync(file.path, file.content);
-    } else {
-      fs.mkdirSync(file.path, { recursive: true });
-    }
-  });
-  return runPath(filepath, options, custom_context);
+	FILES.forEach((file) => {
+		if (fs.existsSync(file.path)) return;
+		if (file.content) {
+			fs.writeFileSync(file.path, file.content);
+		} else {
+			fs.mkdirSync(file.path, { recursive: true });
+		}
+	});
+	return runPath(filepath, options, custom_context);
 };

package/lib/rew/misc/bin.js

@@ -0,0 +1,37 @@
+
+
+const msgpack = require('tiny-msgpack');
+const crypto = require('crypto');
+
+const algorithm = 'aes-256-ctr';
+
+const encrypt = (data, encryptionKey) => {
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv(algorithm, Buffer.from(encryptionKey, 'hex'), iv);
+  const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+  return Buffer.concat([iv, encrypted]);
+};
+
+const decrypt = (data, encryptionKey) => {
+  const iv = data.slice(0, 16);
+  const encryptedData = data.slice(16);
+  const decipher = crypto.createDecipheriv(algorithm, Buffer.from(encryptionKey, 'hex'), iv);
+  const decrypted = Buffer.concat([decipher.update(encryptedData), decipher.final()]);
+  return decrypted;
+};
+
+module.exports.serializeData = (data, encryptionKey) => {
+  return encrypt(msgpack.encode(data), encryptionKey);
+};
+
+module.exports.deserializeData = (buffer, encryptionKey) => {
+  return msgpack.decode(decrypt(buffer, encryptionKey));
+};
+
+module.exports.gen_key = (secret) => {
+  if (secret) {
+    return crypto.createHash('sha256').update(secret).digest('hex');
+  } else {
+    return crypto.randomBytes(32).toString('hex');
+  }
+}

package/lib/rew/misc/findAppInfo.js

@@ -0,0 +1,16 @@
+const jsYaml = require('js-yaml');
+const { findAppPath } = require('./findAppPath');
+const path = require('path');
+const { readFileSync } = require('fs');
+
+module.exports.findAppInfo = function (filepath) {
+	const appPath = findAppPath(path.dirname(filepath));
+	if (appPath) {
+		const config = jsYaml.load(readFileSync(path.join(appPath, 'app.yaml')));
+		return {
+			path: appPath,
+			config,
+		};
+	}
+	return null;
+};

package/lib/rew/misc/findAppPath.js

@@ -0,0 +1,21 @@
+const path = require('path'); // Import the 'path' module
+const fs = require('fs'); // Import the 'path' module
+
+module.exports.findAppPath = (currentDir = __dirname) => {
+	// Check if app.yaml exists in the current directory
+	const appYamlPath = path.join(currentDir, 'app.yaml');
+	if (fs.existsSync(appYamlPath)) {
+		return currentDir;
+	}
+
+	// If not found, move up a directory level
+	const parentDir = path.dirname(currentDir);
+
+	// Check if we reached the root directory
+	if (parentDir === currentDir) {
+		return null; // Not found
+	}
+
+	// Recursively call the function on the parent directory
+	return module.exports.findAppPath(parentDir);
+};

package/lib/rew/misc/req.js

@@ -0,0 +1,7 @@
+const axios = require("axios")
+
+
+module.exports.req = async (url, options = {}) => {
+  return await axios
+    .get(url, { ...options });
+}

package/lib/rew/misc/seededid.js

@@ -0,0 +1,13 @@
+module.exports.seededID = function (seed) {
+	const charCodes = seed.split('').map((char) => char.charCodeAt(0));
+
+	let result = '';
+	let sum = 0;
+
+	for (let i = 0; i < charCodes.length; i++) {
+		sum += charCodes[i];
+		result += String.fromCharCode(((charCodes[i] + sum) % 26) + 97);
+	}
+
+	return result.slice(0, 12);
+};

package/lib/rew/models/enum.js

@@ -1,14 +1,14 @@
 module.exports.cenum = function cenum(values) {
-  var enumObj, i, len, value;
-  // Create an object to hold the enum values
-  enumObj = {};
-  for (i = 0, len = values.length; i < len; i++) {
-    value = values[i];
-    enumObj[value] = value;
-  }
-  // Add a method to check if a value is a valid enum value
-  enumObj.isValid = function (val) {
-    return indexOf.call(enumObj, val) >= 0;
-  };
-  return enumObj;
+	var enumObj, i, len, value;
+	// Create an object to hold the enum values
+	enumObj = {};
+	for (i = 0, len = values.length; i < len; i++) {
+		value = values[i];
+		enumObj[value] = value;
+	}
+	// Add a method to check if a value is a valid enum value
+	enumObj.isValid = function (val) {
+		return indexOf.call(enumObj, val) >= 0;
+	};
+	return enumObj;
 };

package/lib/rew/models/struct.js

@@ -1,41 +1,39 @@
-const { generateRandomID } = require("../functions/id");
+const { generateRandomID } = require('../functions/id');
 
 module.exports.struct = function struct(template) {
-  var key, types, value;
+	var key, types, value;
 
-  types = {};
-  for (key in template) {
-    value = template[key];
-    types[key] = typeof value;
-  }
+	types = {};
+	for (key in template) {
+		value = template[key];
+		types[key] = typeof value;
+	}
 
-  const fun = function (properties = {}) {
-    var defaultValue, instance;
-    instance = {};
-    for (key in template) {
-      defaultValue = template[key];
-      if (key in properties) {
-        value = properties[key];
-        if (defaultValue != "!any" && typeof value !== types[key]) {
-          throw new Error(
-            `Type error: Expected ${types[key]} for ${key}, got ${typeof value}`,
-          );
-        }
-        instance[key] = value;
-      } else {
-        instance[key] = defaultValue == "!any" ? null : defaultValue;
-      }
-    }
-    instance.__proto__ = { '@instance': fun };
-    return instance;
-  };
+	const fun = function (properties = {}) {
+		var defaultValue, instance;
+		instance = {};
+		for (key in template) {
+			defaultValue = template[key];
+			if (key in properties) {
+				value = properties[key];
+				if (defaultValue != '!any' && typeof value !== types[key]) {
+					throw new Error(`Type error: Expected ${types[key]} for ${key}, got ${typeof value}`);
+				}
+				instance[key] = value;
+			} else {
+				instance[key] = defaultValue == '!any' ? null : defaultValue;
+			}
+		}
+		instance.__proto__ = { '@instance': fun };
+		return instance;
+	};
 
-  return fun;
+	return fun;
 };
 
 module.exports.struct.inherits = function (struct, template) {
-  return module.exports.struct({
-    ...struct(),
-    ...template,
-  });
+	return module.exports.struct({
+		...struct(),
+		...template,
+	});
 };

package/lib/rew/modules/compiler.js

@@ -1,206 +1,266 @@
-const { compile } = require("../../coffeescript/coffeescript");
-const { execOptions } = require("../const/opt");
-const { getFile } = require("./fs");
+const { compile } = require('../../coffeescript/coffeescript');
+const { execOptions } = require('../const/opt');
+const { findAppInfo } = require('../misc/findAppInfo');
+const { from_qrew } = require('../qrew/compile');
+const { getFile, file } = require('./fs');
 const babel = require('@babel/core');
+const path = require('path');
 const babelReact = require('@babel/preset-react');
+const { readFileSync } = 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]+'\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 });
-    }
-  }
+	const tokens = [];
+	let currentToken = '';
+
+	for (let i = 0; i < code.length; i++) {
+		const char = code[i];
+		const nextChar = code[i + 1];
 
-  return tokens;
+		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 ValueIfy = (val) => {
+  if(!isNaN(parseFloat(val)) || !isNaN(parseInt(val))){
+    return isNaN(parseInt(val)) ? parseFloat(val) : parseInt(val);
+  } if(val == 'true' || val == 'false') {
+    return val == 'true' ? true : false;
+  } else {
+    return JSON.stringify(val);
+  }
 }
 
+const gnextToken = (i, n, tokens) => {
+	return tokens[i + n] ? (tokens[i + n].type == 'WHITESPACE' ? gnextToken(i, n + 1, tokens) : { token: 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));
-}
+	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 = '';
+	const tokens = tokenizeCoffeeScript(content);
+	let result = '';
 
-  let hooks = [];
+	let hooks = [];
 
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    let { nextToken, n } = gnextToken(i, 1, tokens) || {};
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		let { token: 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;
-        }
-        
-      }
+		if (token.type === 'IDENTIFIER' && token.value === 'opt') {
+			const { token: nextNextToken } = gnextToken(i, 2, tokens) || {};
+			if (nextNextToken && nextNextToken.value == 'jsxPragma') {
+				const { token: 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;
+		}
 
-      const nextLastToken = fnextToken(i, tokens, 'IDENTIFIER');
+    if (token.type === 'COMMENT' && token.value.slice(1).trim() === '@cls') {
+			options.cls = true;
+		}
 
-      if(nextLastToken?.value == 'assert'){
-        result += ', ';
-        i += 3;
+    if (options.cls && token.type === 'OTHER' && token.value === '-' && nextToken.value == '-' && tokens[i-1]?.type == 'WHITESPACE') {
+			// Argument case
+      let offset = 0, writenext = false;
+      const n = gnextToken(i, 2, tokens);
+      let v = gnextToken(i, 3, tokens);
+      if(v.token.type == 'IDENTIFIER' && v.token.value == '$'){
+        writenext = true;
       }
+      result +=  n.token.value + ': ' + (writenext ? '' : (v.token.value == ',' ? 'true, ' : v.token.type == "STRING" ? v.token.value : ValueIfy(v.token.value)));
 
+      i = offset + tokens.indexOf(v.token);
       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)
+		if (token.type === 'IDENTIFIER' && token.value === 'import') {
+			// console.log(nextToken.type);
+			let ind = i + n + 2;
 
-  return result;
-}
+			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 = {}) {
-  let c = compile(compileRewStuff(file.content, options), { ...options, filename: file.path, bare: false, inlineMap: false });
-  if(execOptions.jsx || options.jsx) {
-    c = babel.transformSync(c, {
-      presets: [[babelReact, { pragma: execOptions.jsxPragma }]],
-      plugins: []
-    }).code;
-  }
-  return c;
+	let c = compile(compileRewStuff(file.content, options), {
+		...options,
+		filename: file.path,
+		bare: false,
+		inlineMap: false,
+	});
+	if (execOptions.jsx || options.jsx) {
+		c = babel.transformSync(c, {
+			presets: [[babelReact, { pragma: execOptions.jsxPragma }]],
+			plugins: [],
+		}).code;
+	}
+	return c;
 });
 
 module.exports.compileFile = function (filepath, options = {}) {
-  const f = getFile(filepath);
-  const compiled_code =
-    options.compile == false ? f.content : cpl(f, { ...options });
-
-  return {
-    compiled_code,
-    file: f,
-  };
+	const f = getFile(filepath);
+
+	if(options.qrew || path.extname(filepath) == '.qrew') {
+		f.content = from_qrew(readFileSync(f.path), options.package || findAppInfo(filepath)?.config.package || path.basename(filepath).split('.').slice(0, -1).join('.')).toString();
+	}
+
+	let compiled_code = options.compile == false ? f.content : cpl(f, { ...options });
+
+	return {
+		compiled_code,
+		file: f,
+	};
 };