@makano/rew 1.1.81 → 1.2.0

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,238 +1,266 @@
-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");
+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];
+
+		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;
+	return tokens;
+}
+
+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)
-      : { nextToken: tokens[i + n], n }
-    : null;
+	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);
-        }
-      });
-    }
-  }
+		}
+
+		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;
+		}
 
-  // console.log(result)
+		if (
+			token.type === 'IDENTIFIER' &&
+			token.value === 'pub' &&
+			nextToken &&
+			nextToken.type === 'IDENTIFIER' &&
+			nextToken.value &&
+			nextToken.value !== 'undefined'
+		) {
+			hooks.push({
+				index: i + 1,
+				value: `"${nextToken.value}", `,
+			});
+		}
 
-  return result;
+		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,
+	};
 };

package/lib/rew/modules/fs.js

@@ -1,19 +1,19 @@
-const { struct } = require("../models/struct");
-const fs = require("fs");
+const { struct } = require('../models/struct');
+const fs = require('fs');
 
 const file = (module.exports.file = struct({
-  path: "",
-  content: "",
+	path: '',
+	content: '',
 }));
 
 const readFile = (module.exports.readFile = function readFile(file) {
-  return (file.content = fs.readFileSync(file.path, { encoding: "utf-8" }));
+	return (file.content = fs.readFileSync(file.path, { encoding: 'utf-8' }));
 });
 
 module.exports.getFile = function (filepath) {
-  const f = file({
-    path: filepath,
-  });
-  readFile(f);
-  return f;
+	const f = file({
+		path: filepath,
+	});
+	readFile(f);
+	return f;
 };

package/lib/rew/modules/runtime.js

@@ -1,28 +1,24 @@
-const vm = require("vm");
-const { compileFile } = require("./compiler");
-const { prepareContext } = require("./context");
+const vm = require('vm');
+const { compileFile } = require('./compiler');
+const { prepareContext } = require('./context');
 
 const exec = (module.exports.exec = function (code, context) {
-  return vm.runInNewContext(code, vm.createContext(context), {
-    filename: context.module.filepath,
-    lineOffset: 0,
-    displayErrors: true,
-  });
+	return vm.runInNewContext(code, vm.createContext(context), {
+		filename: context.module.filepath,
+		lineOffset: 0,
+		displayErrors: true,
+	});
 });
 
-module.exports.runPath = function runPath(
-  filepath,
-  options = {},
-  custom_context = {},
-) {
-  const { compiled_code, file } = compileFile(filepath, options);
-  const context = prepareContext(custom_context, options, file.path, runPath);
+module.exports.runPath = function runPath(filepath, options = {}, custom_context = {}) {
+	const { compiled_code, file } = compileFile(filepath, options);
+	const context = prepareContext(custom_context, options, file.path, runPath);
 
-  context.module.compiled = compiled_code;
-  context.process.exit = (int) => process.exit(int);
+	context.module.compiled = compiled_code;
+	context.process.exit = (int) => process.exit(int);
 
-  return {
-    context,
-    returns: exec(compiled_code, context),
-  };
+	return {
+		context,
+		returns: exec(compiled_code, context),
+	};
 };