@makano/rew 1.2.4 → 1.2.6

package/lib/rew/functions/import.js

@@ -6,9 +6,12 @@ const { existsSync, readFileSync } = require('fs');
 const conf = require('../pkgs/conf');
 const jsYaml = require('js-yaml');
 const { execOptions } = require('../const/opt');
+const { REW_FILE_TYPE } = require('../const/ext');
 
 const cachedFiles = [];
-
+module.exports.cleanCache = () => {
+	while(cachedFiles.length) cachedFiles.pop();
+};
 const lookUpInOtherApps = (fullPath) => {
 	const con = conf({});
 	const name = fullPath.indexOf('/') ? fullPath.split('/')[0] : fullPath;
@@ -32,7 +35,7 @@ const lookUpInOtherApps = (fullPath) => {
 module.exports.imp = function (runPath, context) {
 	return function (filename, options = {}) {
 		if (!options) options = {};
-		let type = options.type || 'coffee';
+		let type = options.type || filename.endsWith('.coffee') ? 'coffee' : REW_FILE_TYPE.TYPE;
 		let exports,
 			ispkg = findPackage(filename);
 
@@ -43,8 +46,6 @@ module.exports.imp = function (runPath, context) {
 		let filepath = path.resolve(path.dirname(context.module.filepath), filename);
 		if(path.extname(filepath) == '.qrew') options.qrew = true;
 
-		// console.log(typeof runPath);
-
 		const lookUp = () => {
 			const otherPath = lookUpInOtherApps(filename);
 			if (!otherPath) throw new Error('Module "' + filename + '" not found');
@@ -57,7 +58,7 @@ module.exports.imp = function (runPath, context) {
 			exports = foundCache.exports;
 		}
 
-		if (!ispkg && !existsSync(filepath)) {
+		if (!ispkg && !existsSync(filepath) && !foundCache) {
 			if (Array.isArray(execOptions.resolveExtensions) && execOptions.resolveExtensions.length) {
 				const resolve = execOptions.resolveExtensions.find((ext) =>
 					typeof ext == 'string' ? existsSync(filepath + ext) : existsSync(filepath + (ext.ext || '')),
@@ -72,8 +73,8 @@ module.exports.imp = function (runPath, context) {
 			} else lookUp();
 		}
 
-		const exec = (coptions = {}) =>
-			runPath(
+		const exec = (coptions = {}) => {
+			const r = runPath(
 				filepath,
 				{
 					import: options,
@@ -86,13 +87,18 @@ module.exports.imp = function (runPath, context) {
 					package: context.app ? context.app.config.package : path.basename(filepath)
 				},
 				execOptions.sharedContext == false ? {} : options.context && options.context == 'new' ? {} : context,
-			).context.module.exports;
+			);
+			if(r instanceof Promise){
+				return new Promise((resolve) => r.then(c => resolve(c.context.module.exports)));
+			}
+			return r.context.module.exports;
+		}
 
 		if (ispkg) {
-			const pkg = getPackage(filename)(context);
+			const pkg = getPackage(filename)(context, options);
 			exports = pkg._onImport ? pkg._onImport() : pkg;
 		} else if (foundCache) {
-		} else if (type == 'coffee') {
+		} else if (type == REW_FILE_TYPE.TYPE || type == "coffee") {
 			exports = exec({});
 		} else if (type == 'js') {
 			exports = exec({ compile: false });
@@ -111,7 +117,7 @@ module.exports.imp = function (runPath, context) {
 			}
 		}
 
-		if (options.save && (type == 'js' || type == 'coffee')) {
+		if (options.save && (type == 'js' || type == REW_FILE_TYPE.TYPE || type == "coffee")) {
 			if (typeof options.save == 'string') context[options.save] = exports[i];
 			else
 				for (let i in exports) {
@@ -119,8 +125,23 @@ module.exports.imp = function (runPath, context) {
 				}
 		}
 
-		if (!ispkg) context.module.imports.push(filepath);
-		if (!ispkg) cachedFiles.push({ filepath, exports });
+		// Hehe, i just had an idea for a
+		// descriptive code
+		// you put them in comment blocks
+		// and name it something
+		// then you can simple see 
+		// which part of a code contains a certain
+		// task. cool right?
+	
+		//**  If is not package, post exec section
+		/**/ if (!ispkg) context.module.imports.push(filepath);
+		/**/ if (!ispkg) cachedFiles.push({ filepath, exports });
+		//** 
+
+		//**  Mock imports section	
+		/**/ if(!exports) exports = options.mock;
+		/**/ if(options.mock === null) return null;
+		//** 
 
 		return exports;
 	};

package/lib/rew/functions/require.js

@@ -1,10 +1,26 @@
 const fs = require('fs');
 const path = require('path');
+const { execOptions } = require('../const/opt');
+const { wait } = require('./wait');
+
+const cahcedRequires = {};
+
+const doImp = (path) => wait(async () => await import(resolvedPath));
 
 module.exports.customRequire = function customRequire(modulePath, filePath) {
+	let pathname = modulePath;
+	if (modulePath.startsWith('./') || modulePath.startsWith('../') || path.isAbsolute(modulePath)) {
+		pathname = path.resolve(modulePath);
+	}
+	if(cahcedRequires[pathname]) {
+		return cahcedRequires[pathname];
+	}
 	const resolvedPath = resolveModulePath(modulePath, filePath);
 	if(!resolvedPath) throw new Error('Module '+modulePath+' not found');
-	return require(resolvedPath);
+	const r = cahcedRequires[resolvedPath] ? cahcedRequires[resolvedPath] : execOptions.useImport ? doImp(resolvedPath) : require(resolvedPath);
+	if(!cahcedRequires[resolvedPath]) cahcedRequires[resolvedPath] = r;
+	if(!cahcedRequires[pathname]) cahcedRequires[pathname] = r;
+	return r;
 };
 
 function resolveModulePath(modulePath, filePath) {

package/lib/rew/functions/stdout.js

@@ -4,6 +4,10 @@ const print = (module.exports.print = function print(...args) {
 	return console.log(...args);
 });
 
+module.exports.printf = function printf(buffer, cb) {
+	return process.stdout.write(buffer, cb);
+};
+
 print.stdout = process.stdout;
 print.stdin = process.stdin;
 

package/lib/rew/main.js

@@ -1,17 +1,5 @@
-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 { runPath } = require('./modules/runtime');
 
 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);
 };

package/lib/rew/modules/compiler.js

@@ -1,4 +1,4 @@
-const { compile } = require('../../coffeescript/coffeescript');
+const { compile: compileCivet } = require('../../civet/main');
 const { execOptions } = require('../const/opt');
 const { findAppInfo } = require('../misc/findAppInfo');
 const { from_qrew } = require('../qrew/compile');
@@ -7,6 +7,9 @@ const babel = require('@babel/core');
 const path = require('path');
 const babelReact = require('@babel/preset-react');
 const { readFileSync } = require('fs');
+const { wait } = require('../functions/wait');
+const { REW_FILE_TYPE } = require('../const/ext');
+const { USING_DEFAULT } = require('../const/usage');
 
 function tokenizeCoffeeScript(code) {
 	const tokens = [];
@@ -115,18 +118,25 @@ function compileRewStuff(content, options) {
 		const token = tokens[i];
 		let { token: nextToken, n } = gnextToken(i, 1, tokens) || {};
 
-		if (token.type === 'IDENTIFIER' && token.value === 'opt') {
+		if(token.type == "COMMENT" && i < 2 && token.value.startsWith('#!')){
+			continue;
+		}
+
+		if (token.type === 'IDENTIFIER' && token.value === 'opt.set') {
 			const { token: nextNextToken } = gnextToken(i, 2, tokens) || {};
-			if (nextNextToken && nextNextToken.value == 'jsxPragma') {
+			if (nextNextToken && nextNextToken.value.slice(1).slice(0, -1) == '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') {
+		if (token.type === 'COMMENT' && token.value.slice(1).trim().startsWith('@jsx')) {
 			options.jsx = true;
+			if(token.value.split('@jsx')[1].trim()){
+				options.jsxPragma = token.value.split('@jsx')[1].trim();
+			}
 		}
-
+		
     if (token.type === 'COMMENT' && token.value.slice(1).trim() === '@cls') {
 			options.cls = true;
 		}
@@ -145,7 +155,21 @@ function compileRewStuff(content, options) {
       continue;
 		}
 
-		if (token.type === 'IDENTIFIER' && token.value === 'import') {
+
+		if (token.type === 'IDENTIFIER' && token.value === 'export' && !options.keepImports) {
+			token.value = 'pub';
+		}
+
+		if (token.type === 'IDENTIFIER' && token.value === 'using' && !options.disableUse) {
+			const next = nextToken.value;
+			if(next in USING_DEFAULT) {
+				const { use } = USING_DEFAULT[next];
+				use?.(options);
+				nextToken.value = `"${nextToken.value}"`
+			}
+		}
+
+		if (token.type === 'IDENTIFIER' && token.value === 'import' && !options.keepImports) {
 			// console.log(nextToken.type);
 			let ind = i + n + 2;
 
@@ -160,9 +184,12 @@ function compileRewStuff(content, options) {
 					const exportsTokens = tokens.slice(ind, closingBraceToken.ti);
 					const exports = exportsTokens
 						.filter((t) => t.type === 'IDENTIFIER')
-						.map((t) => t.value)
+						.map((t, i, arr) => t.value == 'as' ? [arr[i-1].value +': '+arr[i+1].value] : t.value)
+						.flat(1)
+						.filter((t, i, arr) => !arr[i+1]?.match(':') && !arr[i-1]?.match(':'))
 						.join(', ');
-					result += `{ ${exports} } = inc ${nameToken.value}`;
+
+					result += `{ ${exports} } ${options.type == 'coffee' ? '=' : ':='} inc ${nameToken.value}`;
 					i = nameToken.ti;
 				}
 			} else if (nextToken.value === '*') {
@@ -171,7 +198,7 @@ function compileRewStuff(content, options) {
 				if (asToken) {
 					const nextToken = fnextToken(asToken.ti + 1, tokens, 'IDENTIFIER');
 					defaultName = nextToken.value;
-					result += `${defaultName} = inc ${nameToken.value}`;
+					result += `${defaultName} ${options.type == 'coffee' ? '=' : ':='} inc ${nameToken.value}`;
 					i = ind + 6;
 				}
 			} else if (nextToken) {
@@ -184,13 +211,15 @@ function compileRewStuff(content, options) {
 						const exportsTokens = tokens.slice(ind, closingBraceToken.ti);
 						const exports = exportsTokens
 							.filter((t) => t.type === 'IDENTIFIER')
-							.map((t) => t.value)
+							.map((t, i, arr) => t.value == 'as' ? [arr[i-1].value +': '+arr[i+1].value] : t.value)
+							.flat(1)
+							.filter((t, i, arr) => !arr[i+1]?.match(':') && !arr[i-1]?.match(':'))
 							.join(', ');
-						result += `{ default: ${defaultName}, ${exports} } = inc ${nameToken?.value || ''}`;
+						result += `{ default: ${defaultName}, ${exports} } ${options.type == 'coffee' ? '=' : ':='} inc ${nameToken?.value || ''}`;
 						i = closingBraceToken.ti + 4;
 					}
 				} else {
-					result += `{ default: ${defaultName} } = inc ${nameToken?.value || ''}`;
+					result += `{ default: ${defaultName} } ${options.type == 'coffee' ? '=' : ':='} inc ${nameToken?.value || ''}`;
 					i = ind + 2;
 				}
 			}
@@ -211,11 +240,18 @@ function compileRewStuff(content, options) {
 			nextToken &&
 			nextToken.type === 'IDENTIFIER' &&
 			nextToken.value &&
-			nextToken.value !== 'undefined'
+			nextToken.value !== 'undefined' && !options.keepImports
 		) {
+			let next = {...nextToken};
+			if(next.value == 'default'){
+				i += 2;
+			}
+			if(next.value == 'class'){
+				next.value = gnextToken(i, n + 1, tokens)?.token.value || "default";
+			}
 			hooks.push({
 				index: i + 1,
-				value: `"${nextToken.value}", `,
+				value: `"${next.value}", `,
 			});
 		}
 
@@ -235,32 +271,92 @@ function compileRewStuff(content, options) {
 	return result;
 }
 
-const cpl = (module.exports.compile = function (file, options = {}) {
-	let c = options.type == 'js' || options.compile == false ? file.content : compile(compileRewStuff(file.content, options), {
+const compileCivetStuff = (file, options) => {
+	const compileOptions = {
 		...options,
-		filename: file.path,
-		bare: false,
+		bare: true,
+		filename: file.content,
 		inlineMap: false,
+		js: true
+	};
+
+	const prepared = compileRewStuff(file.content, options);
+
+	const compiled = options.async ? compileCivet(prepared, compileOptions) : wait(compileCivet, prepared, compileOptions);
+
+	return {
+		compiled,
+		options
+	};
+}
+
+const cpl = (module.exports.compile = function (file, options = {}) {
+	let compiledCode;
+	const result = compileCivetStuff(file, {
+		...options,
+		parseOptions: { 
+			coffeeCompat: options.type == "coffee",
+		}
 	});
+	
+	options = result.options;
+	compiledCode = result.compiled;
+
+	const babelify = (code, options) => babel.transformSync(code, {
+		presets: [
+			...(doJSX ? [[babelReact, { pragma: options.jsxPragma || execOptions.jsxPragma }]] : [])
+		],
+		plugins: [
+			...(doDecorators ? [[require('@babel/plugin-proposal-decorators'), { version: '2023-05' }], [require('@babel/plugin-proposal-class-properties'), { loose: true }], [require('@babel/plugin-transform-class-static-block'), {}]] : [])
+		],
+	}).code;
+
+	const doJSX = execOptions.jsx || options.jsx;
+	const doTypes = execOptions.typescript || options.typescript;
+	const doDecorators = execOptions.decorators || options.decorators;
+	const doBabel = doJSX || doTypes || doDecorators;
+
+	if(compiledCode instanceof Promise){
+		return compiledCode.then((compiledCode) => {
+			if (doBabel) {
+				compiledCode = babelify(compiledCode, options);
+			}
+			return compiledCode;
+		});
+	}
+
 	// console.log(c);
-	if (execOptions.jsx || options.jsx) {
-		c = babel.transformSync(c, {
-			presets: [[babelReact, { pragma: execOptions.jsxPragma }]],
-			plugins: [],
-		}).code;
+	if (doBabel) {
+		compiledCode = babelify(compiledCode, options);
 	}
-	return c;
+	return compiledCode;
 });
 
 module.exports.compileFile = function (filepath, options = {}) {
-	const f = getFile(filepath);
+	const f = typeof filepath == "object" ? filepath : getFile(filepath);
+	if(typeof filepath == "object") filepath = filepath.path;
+	let qrew = false;
 
 	if(options.qrew || path.extname(filepath) == '.qrew') {
+		qrew = true
 		f.content = from_qrew(readFileSync(f.path), options.package || findAppInfo(filepath)?.config.manifest.package || path.basename(filepath).split('.').slice(0, -1).join('.')).toString();
-	}
+		options.type = f.content.split('\n')[0]?.match(/"initFile (.+)"/)?.[1]?.split('.').pop();
+	} 
 
 	let compiled_code =  cpl(f, { ...options });
 
+	if(options.onlyCompile && !qrew){
+		if(compiled_code instanceof Promise){
+			compiled_code.then((r) => {
+				console.log(r);
+				process.exit();
+			});
+		} else {
+			console.log(compiled_code);
+			process.exit();
+		}
+	}
+
 	return {
 		compiled_code,
 		file: f,

package/lib/rew/modules/context.js

@@ -7,6 +7,7 @@ const fsLib = require("../functions/fs");
 const pathLib = require("../functions/path");
 const execLib = require("../functions/exec");
 const { findAppInfo } = require("../misc/findAppInfo");
+const { USING_DEFAULT } = require("../const/usage");
 
 let mainFile = "";
 const isMainFile = (filepath) => filepath == mainFile;
@@ -25,11 +26,12 @@ module.exports.prepareContext = function (
       imports: [],
     },
     imports: {
-      meta: {},
+      meta: { url: new URL('file://'+filepath), main: isMainFile(filepath) },
       assert: options.import ?? {},
     },
     app: findAppInfo(filepath),
     ...fsLib(filepath),
+    __using__: {}
   };
   if (options.useContext) {
     context = {
@@ -91,6 +93,16 @@ module.exports.prepareContext = function (
   context.pub = pubFunction(context);
   context.exports = exportsFunction(context);
 
+  context.using = (name, ...params) => {
+    if(USING_DEFAULT[name]){
+      if(USING_DEFAULT[name].param) {
+        context.__using__[name] = USING_DEFAULT[name].param(...params);
+      }
+    } else {
+      context.__using__[name] = params.length ? params.length > 1 ? [...params] : params : true;
+    }
+  };
+
   if (
     context.module.main ||
     (options.fromMain == true && options.as == "main")

package/lib/rew/modules/runtime.js

@@ -1,5 +1,5 @@
 const vm = require('vm');
-const { compileFile } = require('./compiler');
+const { compileFile, compile } = require('./compiler');
 const { prepareContext } = require('./context');
 const { existsSync, readFileSync } = require('fs');
 const { CONFIG_PATH } = require('../const/config_path');
@@ -7,37 +7,54 @@ const path = require('path');
 
 const preScript = readFileSync(path.join(__dirname, '../const/pre-exec.js'), { encoding: 'utf-8' });
 
-const exec = (module.exports.exec = function (code, context) {
-	return vm.runInNewContext(code, vm.createContext(context), {
+const exec = (module.exports.exec = function (code, context, original = '') {
+	return vm.runInNewContext(code, context.do ? null : vm.createContext(context), {
 		filename: context.module.filepath,
-		lineOffset: -1 - preScript.split('\n').length,
+		lineOffset: (original.split('\n').length + preScript.split('\n').length) - code.split('\n').length,
 		displayErrors: true,
 	});
 });
 
 module.exports.runPath = function runPath(filepath, options = {}, custom_context = {}) {
 	if(filepath.endsWith('.js')) options.type = 'js';
-	let { compiled_code, file } = compileFile(filepath, options);
-	const context = prepareContext(custom_context, options, file.path, runPath);
+	if(filepath.endsWith('.coffee')) options.type = 'coffee';
+	if(filepath.endsWith('.qrew')) options.type = 'qrew';
 
-	context.module.compiled = compiled_code;
-	context.process.exit = (int) => process.exit(int);
+	if(options.import?.async) options.async = true;
+	let { compiled_code, file } = compileFile(options.code ? { content: options.code, path: filepath } : filepath, options);
+	// context.module.compiled = compiled_code;
+	// context.process.exit = (int) => process.exit(int);
 
-	if(context.app){
-		const p = path.join(CONFIG_PATH, context.app.config.manifest.package, 'app');
-		if(existsSync(p) && context.app.path !== p){
-			console.log("App with the same package name has been installed. Conflicts happened. \nTo fix this, change your app's package name or remove the app making the conflict.");
-			return {
-				context: { exports: null },
-				returns: null
+	const doCode = () => {
+		const context = options.import?.takeThisContext ? custom_context : prepareContext(custom_context, options, file.path, runPath);
+	
+		if(context.app){
+			const p = path.join(CONFIG_PATH, context.app.config.manifest.package, 'app');
+			if(existsSync(p) && context.app.path !== p){
+				console.log("App with the same package name has been installed. Conflicts happened. \nTo fix this, change your app's package name or remove the app making the conflict.");
+				return {
+					context: { module: { exports: null } },
+					returns: null
+				}
 			}
 		}
+	
+		compiled_code = preScript+'\n'+compiled_code;
+	
+		return {
+			context,
+			returns: exec(compiled_code, context, file.content),
+		};
 	}
 
-	compiled_code = preScript+compiled_code;
+	if(options.async){
+		return new Promise(async (r, re) => {
+			compiled_code.then((e) => {
+				compiled_code = e;
+				r(doCode());
+			});
+		});
+	}
 
-	return {
-		context,
-		returns: exec(compiled_code, context),
-	};
+	return doCode();
 };

package/lib/rew/pkgs/conf.js

@@ -82,7 +82,7 @@ module.exports = (context) => ({
 			};
 
 			return {
-				get: (key, defaultValue) => getData(optionCenter, key) || defaultValue,
+				get: (key, defaultValue) => getData(optionCenter, key) ?? defaultValue,
 				set: (key, value) => setData(optionCenter, key, value),
 				remove: (key) => removeData(optionCenter, key),
 				reset: () => fs.writeFileSync(optionCenter.root, dumpYaml(defaults)) && (conf[name] = defaults),

package/lib/rew/pkgs/rune.js

@@ -169,6 +169,7 @@ const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 		};
 
 		const update = (caseRecord, newRecord) => {
+
 			let id;
 			if (typeof caseRecord === 'string') {
 				id = caseRecord;
@@ -224,6 +225,9 @@ const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 			if (typeof criteria == 'string') return read(criteria);
 			if (!criteria || typeof criteria !== 'object') return null;
 
+			
+			if (!fs.existsSync(collectionFilePath)) writeDataFile(collectionFilePath, []);
+
 			const data = readDataFile(collectionFilePath);
 			const record =
 				data.find((record) => {
@@ -240,7 +244,6 @@ const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 
 		const remove = (id) => {
 			if ('@rune.id' in id) id = id['@rune.id'];
-			if (!fs.existsSync(collectionFilePath)) return false;
 			let data = readDataFile(collectionFilePath);
 			const index = data.findIndex((record) => record['@rune.id'] === id);
 			if (index !== -1) {
@@ -293,6 +296,8 @@ const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 			return sortedData;
 		};
 
+		if (!fs.existsSync(collectionFilePath)) writeDataFile(collectionFilePath, []);
+
 		return {
 			insert,
 			read,
@@ -377,6 +382,8 @@ const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 			return data;
 		};
 
+		if (!fs.existsSync(mapFilePath)) writeDataFile(mapFilePath, {});
+
 		return { set, get, remove, list, transform };
 	};