@makano/rew 1.2.4 → 1.2.5

package/jsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "checkJs": true,
+    "lib": ["ESNext"],
+    "module": "Node16"
+  },
+  "include": [
+    "./runtime.d.ts"
+  ],
+  "typeAcquisition": {
+    "include": ["./runtime.d.ts"]
+  }
+}

package/lib/rew/cli/cli.js

@@ -48,6 +48,11 @@ yargs(hideBin(process.argv))
 					alias: 'w',
 					describe: 'Watch the file for changes',
 					type: 'boolean',
+				})
+				.option('compile', {
+					alias: 'c',
+					describe: 'Compile and output the javascript',
+					type: 'boolean',
 				});
 		},
 		(argv) => {
@@ -56,7 +61,7 @@ yargs(hideBin(process.argv))
 				log('File not found:'.red.bold, argv.file, ':end');
 				return;
 			}
-			utils.runFileWithArgv(filePath, { watch: argv.watch });
+			utils.runFileWithArgv(filePath, { onlyCompile: argv.compile, watch: argv.watch });
 		},
 	)
 	.command(
@@ -223,6 +228,10 @@ yargs(hideBin(process.argv))
 				alias: 'r',
 				describe: 'Install requirements of the app',
 				type: 'boolean',
+			}).option('verbose', {
+				alias: 'v',
+				describe: 'Verbose',
+				type: 'boolean',
 			}).option('update', {
 				alias: 'u',
 				describe: 'Update the app',
@@ -280,6 +289,20 @@ yargs(hideBin(process.argv))
 			}
 		},
 	)
+
+	.command(
+		'cache <command>',
+		'Manage cache',
+		(yargs) => {
+			yargs.positional('command', {
+				describe: 'Command to clear/list',
+				type: 'string',
+			});
+		},
+		async (argv) => {
+			utils.cache(argv.command)
+		},
+	)
 	.command(
 		'repo <command> [name] [url]',
 		'Manage install repositories',

package/lib/rew/cli/log.js

@@ -4,6 +4,8 @@ const middlePrefix = '├';
 const separator = '│';
 const endPrefix = '╰';
 
+let last = '';
+
 const log = (module.exports.log = function (...toPrint) {
 	let prefix = start ? startPrefix : middlePrefix;
 	let returns = false;
@@ -16,8 +18,10 @@ const log = (module.exports.log = function (...toPrint) {
 		toPrint.pop();
 	}
 	if (prefix == endPrefix && start) prefix = separator;
-	if (!start) console.log(separator);
+	// if(last == endPrefix && prefix == separator) prefix = startPrefix;
+	if (!start) console.log(last == endPrefix ? startPrefix : separator);
 	if (start) start = false;
+	last = prefix;
 	if (returns) return [prefix, ...toPrint].join(' ');
 	else console.log(prefix, ...toPrint);
 });

package/lib/rew/cli/run.js

@@ -1,8 +1,8 @@
 // run.js
 const { run } = require('../main');
 
-function exec(filePath, argv) {
-	return run(filePath, { argv })?.context?.module?.imports || [];
+function exec(filePath, argv, options = {}) {
+	return run(filePath, { argv, ...options })?.context?.module?.imports || [];
 }
 
 module.exports = { execRewFile: exec };

package/lib/rew/cli/utils.js

@@ -14,9 +14,14 @@ const { req } = require('../misc/req');
 const { CONFIG_PATH } = require('../const/config_path');
 const { watch } = require('chokidar');
 const { execRewFile } = require('./run');
+const { seededID } = require('../misc/seededid');
+const loading = require('loading-cli');
+const sleep = require('../functions/sleep');
+const { gen_key } = require('../misc/bin');
 
 const binpath = path.join(conf({}).create('').root, '.bin');
 const logspath = path.join(conf({}).create('').root, '.logs');
+const cachepath = path.join(conf({}).create('').root, '.cache');
 const localBinPath = path.join(binpath, '../../../', 'bin');
 
 module.exports = {
@@ -30,7 +35,7 @@ module.exports = {
 
 		const runIt = () => {
 			if (options.watch) console.clear();
-			const imports = execRewFile(filePath, [filePath, ...(argv || [])]);
+			const imports = execRewFile(filePath, [filePath, ...(argv || [])], { onlyCompile: options?.onlyCompile });
 			if (options.watch) {
 				imports.forEach((file) => {
 					watchIt(file);
@@ -59,15 +64,19 @@ module.exports = {
 			if (!fullPath || fullPath == 'list') {
 				return fs.readdirSync(con.CONFIG_PATH).join('\n');
 			} else {
-				const name = fullPath.indexOf('/') ? fullPath.split('/')[0] : fullPath;
-				const dpath = fullPath.indexOf('/') ? fullPath.split('/').slice(1).join('/') : '';
+				let name = fullPath.indexOf('/') ? fullPath.split('/')[0] : fullPath;
+				let dpath = fullPath.indexOf('/') ? fullPath.split('/').slice(1).join('/') : '';
+				if(fullPath.startsWith('/')){ 
+					dpath = name;
+					name = '';
+				}
 				const root = con.create(name);
 				if (dpath) {
 					const fp = path.join(root.root, dpath);
-					if (fs.existsSync(fp) && fs.statSync(fp).isDirectory()) {
+					if (!fullPath.startsWith('/') && fs.existsSync(fp) && fs.statSync(fp).isDirectory()) {
 						return fs.readdirSync(fp).join('\n');
 					} else {
-						const o = con.create(name).optionCenter(dpath);
+						const o = dpath && dpath !== '/' ? root.optionCenter(dpath) : root.optionCenter('_default');
 						return key ? o.get(key) : o.getAll(true);
 					}
 				} else {
@@ -75,14 +84,18 @@ module.exports = {
 				}
 			}
 		} else {
-			const name = fullPath.indexOf('/') ? fullPath.split('/')[0] : fullPath;
-			const dpath = fullPath.indexOf('/') ? fullPath.split('/')[1] : '';
-			if (name && key) {
+			let name = fullPath.indexOf('/') ? fullPath.split('/')[0] : fullPath;
+			let dpath = fullPath.indexOf('/') ? fullPath.split('/')[1] : '';
+			if(fullPath.startsWith('/')){ 
+				dpath = name == '/' ? '_default' : name;
+				name = '';
+			}
+			if (key) {
 				const root = con.create(name);
 				const o = dpath ? root.optionCenter(dpath) : root;
 				if (command == 'set') {
 					if (value) {
-						o.set(key, value);
+						o.set(key, value == 'false' || value == 'true' ? (value == 'true' ? true : false) : !isNaN(parseFloat(value)) ? parseFloat(value) : value);
 					} else {
 						log('Value not specified', ':end');
 					}
@@ -90,7 +103,7 @@ module.exports = {
 					o.remove(key);
 				}
 			} else {
-				log(!name ? 'Path not specified' : 'Key not specified', ':end');
+				log('Key not specified', ':end');
 			}
 		}
 	},
@@ -113,6 +126,10 @@ module.exports = {
 				fs.writeFileSync(path.join(projectPath, '.gitignore'), `node_modules/\npackage-lock.json`);
 				execSync('cd ' + projectPath + ' && git init . && git branch -m main', { stdio: 'ignore' });
 			}
+			if(project.intellisense){
+				fs.copyFileSync(path.join(__dirname, '../../../jsconfig.json'), path.join(projectPath, 'jsconfig.json'));
+				fs.copyFileSync(path.join(__dirname, '../../../runtime.d.ts'), path.join(projectPath, 'runtime.d.ts'));
+			}
 			execSync('cd ' + projectPath + ' && npm init -y', { stdio: 'ignore' });
 			// log('Installing '+npm_package_name);
 			// exec('cd '+projectPath+' && npm i '+npm_package_name, (err) => {
@@ -130,9 +147,12 @@ module.exports = {
 			rl.question(logget(' Package Name: '.blue), (pkg) => {
 				if (pkg.trim()) {
 					project.package = pkg.trim();
-					rl.question(logget('󰊢 Use git(y/N): '.yellow.bold), (use_git) => {
-						project.git = use_git.toLowerCase() == 'y' || use_git.toLowerCase() == 'yes';
-						create();
+					rl.question(logget(' Use intellisense declarations ? (y/N): '.magenta.bold), (inteli) => {
+						project.intellisense = inteli.toLowerCase() == 'y' || inteli.toLowerCase() == 'yes';
+						rl.question(logget('󰊢 Use git ? (y/N): '.yellow.bold), (use_git) => {
+							project.git = use_git.toLowerCase() == 'y' || use_git.toLowerCase() == 'yes';
+							create();
+						});
 					});
 				} else {
 					rl.close();
@@ -195,28 +215,29 @@ module.exports = {
 			});
 			log(' Installing '.blue + pname.green.bold);
 			log(' Package'.blue + ': ' + p.name.green + '@' + p.version.yellow);
-			if (p.descriptiondescription) {
-				log(' Description'.blue + ': ' + p.description);
+			if (p.description) {
+				log(' Description'.blue + '\n' + p.description.split('\n').map((i, ind, a) => '  '+(ind == 0 && a.length > 1 ? log.startPrefix : (a.length-1 == ind ? log.endPrefix : log.middlePrefix))+' '+i).join('\n'), ':end');
+			}
+			if (p.keywords && p.keywords.length) {
+				log(' Tags'.blue + '\n  ' + log.endPrefix + p.keywords.map(i => '#'+i).join(' '), ':end')
 			}
 			const done = (f) => {
 				if (f.toLowerCase() == 'y' || f.toLowerCase() == 'yes') {
 					if (fs.existsSync(installPath)) {
 						execSync(`rm -r ${installPath}`);
 					}
-					execSync(`cp -r ${apppath} ${installPath}`);
-					execSync(`chmod 444 ${installPath}/app.yaml`);
-					if (rmidir) {
-						execSync(`rm -r ${apppath}`);
-					}
-					log(' Installed '.green + pname.cyan.bold, c.install ? '' : ':end');
-					if (c.install) {
-						if (c.install.build) {
-							log(' Building'.blue);
+					if (c.install?.build) {
+						log(' Building'.blue);
+						try{
 							this.build({
 								...c.install.build,
-								file: path.join(installPath, c.install.build.file)
+								file: path.join(apppath, c.exec[c.install.build.file] || c.install.build.file)
 							});
-						}
+						} catch(e){}
+					}
+					execSync(`cp -r ${apppath} ${installPath}`);
+					execSync(`chmod 444 ${installPath}/app.yaml`);
+					if (c.install) {
 						if (c.install.commands) {
 							for (let command of c.install.commands) {
 								try{
@@ -224,7 +245,7 @@ module.exports = {
 								} catch(e){
 									const logFile = path.join(logspath, 'logs-'+Date.now()+'.log');
 									fs.writeFileSync(logFile, e.toString() +'\n'+ e.stack);
-									log(` Command Failed: ${command}, check logs at ${logFile}`, ':end');
+									log(` Command Failed: ${command}, check logs at ${logFile}`);
 								}
 							}
 						}
@@ -232,28 +253,32 @@ module.exports = {
 							this.runFileWithArgv(path.join(installPath, c.exec[c.install.file] || c.install.file), {}, []);
 						}
 						if (c.install.requirements) {
-							this.installReq(c);
+							this.installReq(c, opts);
 						}
 						if (c.install.exec) {
 							// this.installReq(c);
-							for (let i in c.install.exec) {
-								let iff = c.install.exec[i];
-								if (iff in c.exec) iff = c.exec[iff];
-								const file = path.join(installPath, iff);
-								const filepath = path.join(binpath, i);
-								const binfp = path.join(localBinPath, i);
-								if (!fs.existsSync(localBinPath)) fs.mkdirSync(localBinPath, { recursive: true });
-								fs.writeFileSync(filepath, `#!/usr/bin/env bash\n#@app.${pname}\nrew ${file} $*`);
-								fs.chmodSync(filepath, '755');
-								fs.linkSync(filepath, binfp);
+							if(conf({}).create('').get('executables') == false){
+								log(' Ignoring executables'.blue);
+							} else {
+								for (let i in c.install.exec) {
+									let iff = c.install.exec[i];
+									if (iff in c.exec) iff = c.exec[iff];
+									const file = path.join(installPath, iff);
+									const filepath = path.join(binpath, i);
+									const binfp = path.join(localBinPath, i);
+									if (!fs.existsSync(localBinPath)) fs.mkdirSync(localBinPath, { recursive: true });
+									fs.writeFileSync(filepath, `#!/usr/bin/env bash\n#@app.${pname}\nrew ${file} $*`);
+									fs.chmodSync(filepath, '755');
+									if(fs.existsSync(binfp)) fs.unlinkSync(binfp);
+									fs.linkSync(filepath, binfp);
+								}
 							}
 						}
+
+						log(' Installed '.green + pname.cyan.bold, ':end');
 					}
 					rl.close();
 				} else {
-					if (rmidiri) {
-						execSync(`rm -rf ${apppath}`);
-					}
 					log(' Canceled install'.red.bold, ':end');
 					rl.close();
 				}
@@ -355,21 +380,51 @@ module.exports = {
 		processFile(filePath, importsArray);
 		log('󰈔 Compiled'.yellow, (importsArray.length + 1 + '').blue, `file${importsArray.length ? 's' : ''}.`.yellow, ':end');
 	},
-	async cloneGit(gitpath) {
+	cache(command){
+		if(command == 'list'){
+			console.log(fs.readdirSync(cachepath).join('\n').trim());
+		} else {
+			fs.readdirSync(cachepath).forEach(file => fs.rmSync(path.join(cachepath, file), { recursive: true }));
+		}
+	},
+	async cloneGit(gitpath, opts) {
 		const p = gitpath.split('github:')[1];
+		const clonePath = path.join(cachepath, 'rew-git-clone-'+gen_key(gitpath).substring(0, 12));
 		const url = `https://github.com/${p}`;
-		const apiurl = `https://api.github.com/repos/${p}`;
+		const apiurl = `https://api.github.com/repos/${p}/commits`;
+		const load = loading("Finding Repo...".yellow).start();
 		try {
 			const response = await req(apiurl);
-			if (response.status !== 200) return log(' Repo not found'.red.bold, ':end');
-			log(''.blue, 'Cloning from github'.yellow);
-			const tempPath = '/tmp/rew-git-clone-' + p.replace(/\//g, '_') + '-' + generateRandomID();
-			execSync(`git clone ${url} ${tempPath}`, { stdio: 'ignore' });
-			log(''.blue, 'Installing deps...'.yellow);
-			execSync(`cd ${tempPath} && npm i`);
-			return tempPath;
+			if (response.status !== 200) {
+				load.stop();
+				return log(' Package not found in github'.red.bold, ':end');
+			}
+			let pull = false;
+			if(fs.existsSync(clonePath)){
+				if(fs.existsSync(path.join(clonePath, response.data[0].sha))){
+					load.stop();
+					log('Found Cache'.yellow);
+					return clonePath+'/clone';
+				} else {
+					pull = true;
+				}
+			}
+			fs.mkdirSync(clonePath, { recursive: true });
+			fs.writeFileSync(path.join(clonePath, response.data[0].sha), '');
+			load.text = 'Cloning from github'.blue.bold;
+			await sleep(100)
+			if(pull) execSync(`cd ${clonePath}/clone && git pull`, { stdio: opts.verbose ? 'inherit' : 'ignore' });
+			else execSync(`git clone ${url} ${clonePath}/clone`, { stdio: opts.verbose ? 'pipe' : 'ignore' });
+			load.text = 'Installing npm packages'.green.bold;
+			await sleep(100)
+			execSync(`cd ${clonePath}/clone && npm i`, { stdio: opts.verbose ? 'inherit' : 'ignore' });
+			load.stop();
+			return clonePath+'/clone';
 		} catch (e) {
-			log(' Repo not found'.red.bold, ':end');
+			const logFile = path.join(logspath, 'logs-'+Date.now()+'.log');
+			fs.writeFileSync(logFile, e.toString() +'\n'+ e.stack);
+			load.stop();
+			log(' Something went wrong, check logs at'.red.bold, logFile.green, ':end');
 		}
 	},
 	findRepo(repo) {
@@ -377,7 +432,7 @@ module.exports = {
 		return repos.get(repo);
 	},
 	async installAppFrom(path, opts) {
-		if (path.startsWith('github:')) this.installApp(await this.cloneGit(path), opts, true, true);
+		if (path.startsWith('github:')) this.installApp(await this.cloneGit(path, opts), opts, true);
 		else if (path.startsWith('@')) this.fromRepo(path, opts);
 		else this.installApp(path, opts, null, null);
 	},
@@ -465,7 +520,7 @@ module.exports = {
 				console.log(Object.keys(confInstance.getAll()).join('\n'));
 			}
 		} else if (command === 'delete') {
-			confInstance.remove('repos');
+			confInstance.remove(key);
 		} else {
 			log(' Invalid command'.red.bold, ':end');
 		}
@@ -474,6 +529,7 @@ module.exports = {
 		log('First time init')
 		conf({}).create('').optionCenter('repos').set('rewpkgs', '//raw.githubusercontent.com/kevinJ045/rewpkgs/main/main.yaml');
 		fs.mkdirSync(binpath, { recursive: true });
+		fs.mkdirSync(cachepath, { recursive: true });
 		fs.mkdirSync(logspath, { recursive: true });
 	}
 };

package/lib/rew/const/default.js

@@ -12,6 +12,7 @@ const { curl } = require('../functions/curl');
 const { wait } = require('../functions/wait');
 const { scheduleFrame } = require('../functions/misc');
 const { jsons, yaml, json, yamls } = require('../functions/json');
+const { generateRandomID } = require('../functions/id');
 
 module.exports = {
 	cenum,
@@ -49,6 +50,8 @@ module.exports = {
 	yaml,
 	yamls,
 
+	genID: generateRandomID,
+
 	curl,
 
 	print,

package/lib/rew/const/opt.js

@@ -1,6 +1,6 @@
 const execOptions = {
 	sharedContext: true,
-	resolveExtensions: [{ ext: '.js', options: { type: 'js' } }, { ext: '.qrew', options: { qrew: true } }, '.coffee'],
+	resolveExtensions: ['.coffee', { ext: '.js', options: { type: 'js' } }, { ext: '.qrew', options: { qrew: true } }],
 	nativeRequire: false,
 	cwdAlias: '$',
 	jsxPragma: 'createElement',

package/lib/rew/functions/exec.js

@@ -23,8 +23,8 @@ module.exports = (currentFile) => {
 		);
 	};
 
-	function spawn(command, options) {
-		return shell.spawn(command, options);
+	function spawn(command, ...args) {
+		return shell.spawn(command, ...args);
 	}
 
 	return { exec, spawn };

package/lib/rew/functions/id.js

@@ -1,5 +1,5 @@
-module.exports.generateRandomID = function generateRandomID(length = 12) {
-	const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+module.exports.generateRandomID = function generateRandomID(length = 12, _characters) {
+	const characters = _characters || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
 	const charactersLength = characters.length;
 	let randomID = '';
 

package/lib/rew/functions/import.js

@@ -57,7 +57,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 || '')),
@@ -119,8 +119,24 @@ 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;
+		/**/ if(!exports) throw new Error('Import '+filename+' does not export anything. Use the "mock" option to mock a value.');
+		//** 
 
 		return exports;
 	};

package/lib/rew/modules/compiler.js

@@ -145,6 +145,19 @@ function compileRewStuff(content, options) {
       continue;
 		}
 
+
+		if (token.type === 'IDENTIFIER' && token.value === 'let') {
+			result += '`'
+			hooks.push({
+				index: fnextToken(i, tokens, 'OTHER', ';').ti,
+				value: `\``,
+			});
+		}
+
+		if (token.type === 'IDENTIFIER' && token.value === 'export') {
+			token.value = 'pub';
+		}
+
 		if (token.type === 'IDENTIFIER' && token.value === 'import') {
 			// console.log(nextToken.type);
 			let ind = i + n + 2;
@@ -213,9 +226,16 @@ function compileRewStuff(content, options) {
 			nextToken.value &&
 			nextToken.value !== 'undefined'
 		) {
+			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}", `,
 			});
 		}
 
@@ -254,13 +274,20 @@ const cpl = (module.exports.compile = function (file, options = {}) {
 
 module.exports.compileFile = function (filepath, options = {}) {
 	const f = getFile(filepath);
+	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();
-	}
+	} 
 
 	let compiled_code =  cpl(f, { ...options });
 
+	if(options.onlyCompile && !qrew){
+		console.log(compiled_code);
+		process.exit();
+	}
+
 	return {
 		compiled_code,
 		file: f,

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 };
 	};
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makano/rew",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "A simple coffescript runtime and app manager",
   "main": "main.js",
   "directories": {
@@ -11,6 +11,8 @@
   },
   "files": [
     "lib/",
+    "runtime.d.ts",
+    "jsconfig.json",
     "main.js",
     "README.md"
   ],
@@ -38,6 +40,7 @@
     "colors": "^1.4.0",
     "deasync": "^0.1.30",
     "js-yaml": "^4.1.0",
+    "loading-cli": "^1.1.2",
     "tiny-msgpack": "^2.2.0",
     "uuid": "^9.0.1",
     "vm": "^0.1.0",

package/runtime.d.ts

@@ -0,0 +1,371 @@
+
+interface ImportOptions {
+  /**
+   * Determines how to import the given module
+   */
+  type: 'js' | 'coffee' | 'yaml' | 'json' | 'qrew';
+  [key: string]: any;
+}
+
+interface ModuleConfOptionCenter {
+  /**
+   * Get a config key
+   * @param key The key of the config to get
+   * @param defaultValue The default value ig null
+   * @returns The value of the key or the defaultValue if it's null.
+   */
+  get: <T = any>(key: string, defaultValue?: T) => T
+  /**
+   * Set a config key
+   * @param key The key of the config to set
+   * @param value The value to set it to
+   * @returns true if it was a success
+   */
+  set: <T = any>(key: string, value: T) => boolean
+  /**
+   * Removes a key from the config
+   * @param key The key of the config to remove
+   * @returns true if it was a success
+   */
+  remove: (key: string) => boolean
+  /**
+   * Resets the entire config option center to it's default value
+   */
+  reset: () => boolean
+  /**
+   * Get all values in an option center
+   * @param str 
+   * @returns 
+   */
+  getAll: (() => string) | ((str?: false) => Record<string, any>)
+}
+
+interface ModuleConf extends ModuleConfOptionCenter {
+  /**
+   * A separate options file for a related set of options
+   * @param name The option center full path
+   * @param defaults The default values
+   * 
+   * @example 
+   * conf = imp 'conf'
+   * 
+   * animations = conf.optionCenter 'animations', enable: false, speed: '1x'
+   * 
+   * if animations.get 'enable'
+   *  animate animations.get 'speed'
+   */
+  optionCenter: (name: string, defaults?: any) => ModuleConfOptionCenter;
+  /**
+   * Manage Static files
+   */
+  staticFile: (name: string, defaults?: any) => {
+    write: (value: any, ifExists?: boolean) => this,
+    read: (to?: string | object) => string | object | Buffer,
+    fileRoot: string,
+    exists: boolean
+  }
+}
+
+interface ModuleEnv {
+  has: (key: string) => boolean,
+  get: (key: string) => string,
+  set: (key: string, value: string) => boolean,
+  rm: (key: string) => boolean,
+  is: (key: string, value: string) => boolean,
+}
+
+interface ModuleRuneDBCollcetion {
+  insert(record: object): any; 
+  read(id: string | object, evaluate?: boolean): any; 
+  update(caseRecord: string | object, newRecord: object): any; 
+  remove(id: string | object): boolean;
+  find(criteria: string | object): any; 
+  map(cb: (data: any[]) => any[], mutate?: boolean): any[]; 
+  transform(cb: (data: any[]) => any[], mutate?: boolean): any[]; 
+  filter(cb: (data: any[]) => boolean, mutate?: boolean): any[]; 
+  sort(cb: (a: any, b: any) => number, mutate?: boolean): any[]; 
+  list(): any[];
+}
+
+interface ModuleRuneDBMap {
+  set(key: string, value: any): void;
+  get(key: string): any | null;
+  remove(key: string): boolean;
+  transform(cb: (data: any) => any, mutate?: boolean): any;
+  list(): { [key: string]: any };
+}
+
+interface ModuleRuneDB {
+  collection: (name: string) => ModuleRuneDBCollcetion
+  map: (name: string) => ModuleRuneDBMap
+  findRef: (ref: string) => any
+  setData: (data: Record<string, any>) => void
+  getData: () => Record<string, any>
+  makeRef(value: object, props?: string): string | null;
+}
+
+interface ModuleRune {
+  db(dbname: string, data?: object, encryptionKey?: string): ModuleRuneDB;
+  genKey(secret: string): string;
+  push(...values: any[]): PushChange;
+  pop(...values: any[]): PopChange;
+}
+
+interface ModuleThreads {
+  thread: (cb: Function) => {
+    stopAll: () => void
+    start: (context: Record<string, any>) => {
+      on: (event: string, callback: (data) => void) => void;
+      off: (event: string, callback: (data) => void) => void;
+      emit: (event: string, data: any) => void;
+      get: () => Promise,
+      stop: () => void 
+    }
+  }
+}
+
+declare function imp(path: "conf", options?: ImportOptions): ModuleConf;
+declare function imp(path: "env", options?: ImportOptions): ModuleEnv;
+declare function imp(path: "rune", options?: ImportOptions): ModuleRune;
+declare function imp(path: "threads", options?: ImportOptions): ModuleThreads;
+declare function imp(path: string, options?: ImportOptions): any;
+
+declare const inc = imp;
+
+declare function require(moduleName: string): any;
+
+interface Module {
+  exports: any;
+  filepath: string;
+  main: boolean;
+  impots: string[];
+  compiled: string
+}
+
+declare const module: Module;
+
+interface Imports {
+  meta: {},
+  assets: any
+}
+
+declare const imports: Imports;
+
+declare const process: {
+  argv: string[],
+  target: ReturnType<typeof emitter>,
+  __execFile: string,
+  env: Record<string, any>,
+  cwd: () => string,
+  arch: string,
+  exit: () => void
+};
+
+interface AppConfig {
+  manifest: {
+    package: string
+  }
+}
+
+declare const app: {
+  path: string,
+  config: AppConfig
+}
+
+
+declare function read(filepath: string, options?: { encoding: string }): string;
+
+declare function realpath(filepath: string, options?: { encoding: string }): string;
+
+declare function write(filepath: string, content: any, options?: any): void;
+
+declare function exists(filepath: string, options?: any): boolean;
+
+declare function fstat(filepath: string, options?: any): any; 
+
+declare function rm(filepath: string, options?: any): void;
+
+declare function chmod(filepath: string, mode: any, options?: any): void;
+
+declare function mkdir(filepath: string, options?: any): void;
+
+declare function ls(filepath: string, options?: any): string[];
+
+declare function struct(template: { [key: string]: any }): (...args: any[]) => any; 
+
+declare function future(callback: (resolve: (data: any) => void, reject: (data: any) => void) => void, timeout?: number, defData?: any): {
+  pipe(callback: (data: any) => any): Promise<any>;
+  last(callback: (data: any) => any): Promise<any>;
+  catch(callback: (data: any) => any): Promise<any>;
+  resolve(data: any): void;
+  reject(data: any): void;
+  wait(): Promise<any>;
+};
+declare namespace future {
+  function promise(promse: Promise<any>, timeout?: number, defData?: any): ReturnType<typeof future>;
+}
+
+declare function emitter(): {
+  on(event: string | string[], callback: (...args: any[]) => void, props?: {}): ReturnType<typeof emitter>;
+  off(event: string | string[], callback: (...args: any[]) => void, removable?: (event: any) => void): ReturnType<typeof emitter>;
+  emit(event: string | string[], ...data: any[]): ReturnType<typeof emitter>;
+};
+declare function exec(command: string, options?: { output?: boolean }): any; 
+declare namespace exec {
+  function background(command: string, options?: any, callback?: (...args: any[]) => void): any; 
+}
+declare function spawn(command: string, ...args: any[]): any; 
+
+declare function typedef(value: any, strict?: boolean): { strict: boolean; defaultValue: any; class: Function; type: string; isConstucted: boolean; isEmpty: boolean };
+
+declare function typeis(obj: any, typeDef: any): boolean;
+
+declare function typex(child: any, parent: any): boolean;
+
+declare function typei(child: any, parent: any): boolean;
+
+declare function int(str: string): number;
+
+declare namespace int {
+  const type: { strict: boolean; defaultValue: number; class: Function; type: string; isConstucted: boolean; isEmpty: boolean };
+}
+declare function float(str: string): number;
+declare namespace float {
+  const type: { strict: boolean; defaultValue: number; class: Function; type: string; isConstucted: boolean; isEmpty: boolean };
+}
+declare function num(str: string): number;
+declare namespace num {
+  const type: { strict: boolean; defaultValue: number; class: Function; type: string; isConstucted: boolean; isEmpty: boolean };
+}
+declare function str(str: any): string;
+declare namespace str {
+  const type: { strict: boolean; defaultValue: string; class: Function; type: string; isConstucted: boolean; isEmpty: boolean };
+}
+declare function bool(value: any): boolean;
+declare namespace bool {
+  const type: { strict: boolean; defaultValue: boolean; class: Function; type: string; isConstucted: boolean; isEmpty: boolean };
+}
+declare function isEmpty(value: any): boolean;
+declare function clone(value: any): any;
+declare function deepClone(value: any): any;
+declare function merge(obj1: any, obj2: any): any;
+declare const uniqueId: () => string;
+declare function filter(arr: any[], fn: (value: any) => boolean): any[];
+declare function reduce(arr: any[], fn: (acc: any, value: any) => any, initial: any): any;
+declare function compose(...fns: Function[]): (initialValue: any) => any;
+declare function curry(fn: Function): (...args: any[]) => any;
+declare function json(thing: string): any;
+declare function jsons(thing: any): string;
+declare function yaml(thing: any): any;
+declare function yamls(thing: any): string;
+
+
+/**
+ * Makes a HTTP request to the specified URL.
+ * @param url The URL to request.
+ * @param options The options for the request.
+ * @returns A promise resolving to the response or other specified output based on the options.
+ */
+declare function curl(url: string, options: {
+  /**
+   * Indicates whether to return a promise.
+   */
+  a: true,
+  /**
+   * Indicates whether to return the response as plain text.
+   */
+  text: true,
+  o?: string
+}): Promise<string>;
+/**
+ * Makes a HTTP request to the specified URL.
+ * @param url The URL to request.
+ * @param options The options for the request.
+ * @returns A promise resolving to the response or other specified output based on the options.
+ */
+declare function curl(url: string, options: {
+  /**
+   * Indicates whether to return a promise.
+   */
+  a: true,
+  /**
+   * Indicates whether to return the response as JSON.
+   */
+  json: true,
+  /**
+   * The file path to output the response.
+   */
+  o?: string
+}): Promise<object>;
+/**
+ * Makes a HTTP request to the specified URL.
+ * @param url The URL to request.
+ * @param options The options for the request.
+ * @returns A promise resolving to the response or other specified output based on the options.
+ */
+declare function curl(url: string, options: {
+  /**
+   * Indicates whether to return a promise.
+   */
+  a: true,
+  /**
+   * The file path to output the response.
+   */
+  o?: string
+}): Promise<Response>;
+
+/**
+ * Makes a HTTP request to the specified URL.
+ * @param url The URL to request.
+ * @param options The options for the request.
+ * @returns A promise resolving to the response or other specified output based on the options.
+ */
+declare function curl(url: string, options?: {
+  /**
+   * Indicates whether to return a promise.
+   */
+  a?: boolean,
+  /**
+   * The file path to output the response.
+   */
+  o?: string,
+  /**
+   * Indicates whether to return the response as JSON.
+   */
+  json?: boolean,
+  /**
+   * Indicates whether to return the response as plain text.
+   */
+  text?: boolean
+}): ReturnType<typeof future>;
+
+
+
+
+declare function print(...args: any[]): void;
+declare namespace print {
+  const stdout: WriteStream;
+  const stdin: ReadStream;
+};
+
+declare function input(prompt: string): string;
+
+
+declare const basename: (path: string) => string;
+declare const dirname: (path: string) => string;
+declare const extname: (path: string) => string;
+declare const pjoin: (...paths: string[]) => string;
+declare const presolve: (...paths: string[]) => string;
+
+declare function exports(value: any) : any;
+
+declare function pub(value: any) : any;
+declare function pub(name: string, value: any) : any;
+
+declare const opt: {
+  set: (key: string, value: any) => void;
+  get: (key: string) => any,
+  push: (key: string, value: any) => any,
+  pop: (key: string) => any,
+}
+